@caperjs/core 0.1.0

package/cli/create.mjs

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+import * as p from '@clack/prompts';
+import { bold, cyan } from 'kleur/colors';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { promisify } from 'node:util';
+import shell from 'shelljs';
+import { copy, dist, mkdirp, package_manager } from './utils.mjs';
+
+let packageManager = package_manager;
+
+const AVAILABLE_PLUGINS = [
+  {
+    name: '@caperjs/plugin-rollbar',
+    displayName: 'Rollbar',
+    description: 'Rollbar error tracking and monitoring',
+  },
+  {
+    name: '@caperjs/plugin-rive',
+    displayName: 'Rive',
+    description: 'Rive animation integration',
+  },
+  {
+    name: '@caperjs/plugin-colyseus',
+    displayName: 'Colyseus',
+    description: 'Colyseus multiplayer game server integration',
+  },
+  {
+    name: '@caperjs/plugin-google-analytics',
+    displayName: 'Google Analytics',
+    description: 'Google Analytics integration',
+  },
+  {
+    name: '@caperjs/plugin-crunch',
+    displayName: 'Crunch Physics',
+    description: 'Crunch physics engine integration',
+  },
+  {
+    name: '@caperjs/plugin-firebase',
+    displayName: 'Firebase',
+    description: 'Firebase plugin for cloud data persistence',
+  },
+];
+
+/**
+ * Ensures a version string has the ^ prefix unless it's a URL or specific commit
+ * @param {string} version
+ * @returns {string}
+ */
+function ensureCaretPrefix(version) {
+  // Skip if version is a URL, git repo, or specific commit
+  if (version.includes('://') || version.includes('github:') || version.includes('#')) {
+    return version;
+  }
+  // Skip if version already has a prefix
+  if (version.startsWith('^') || version.startsWith('~') || version.startsWith('>') || version.startsWith('<')) {
+    return version;
+  }
+  return `^${version}`;
+}
+
+async function write(cwd, options) {
+  await mkdirp(cwd);
+  await write_template_files(
+    cwd,
+    options.template,
+    options.applicationNameForPkg,
+    options.applicationName,
+    options.defaultName,
+    options.plugins,
+  );
+}
+
+function getFiles(dirPath) {
+  let files = [];
+
+  const dirFiles = fs.readdirSync(dirPath, { withFileTypes: true });
+  dirFiles.forEach((file) => {
+    const name = file.name;
+    if (fs.statSync(path.join(dirPath, name)).isDirectory()) {
+      files = files.concat(getFiles(path.join(dirPath, name)));
+    } else {
+      files.push({ name: path.join(dirPath, name) });
+    }
+  });
+
+  return files;
+}
+
+/**
+ * @param {string} template
+ * @param {string} applicationNameForPkg
+ * @param {string} name
+ * @param {string} applicationName
+ * @param {string} cwd
+ * @param {string[]} plugins
+ */
+function write_template_files(cwd, template, applicationNameForPkg, applicationName, defaultName, plugins) {
+  const dir = dist(`templates/${template}`);
+  copy(`${dir}/package.template.json`, `${cwd}/package.json`);
+
+  const dirPath = `${dir}`;
+  const files = getFiles(dirPath);
+  files.forEach((file) => {
+    const dest = path.join(cwd, file.name.replace(dirPath, ''));
+    copy(file.name, dest);
+  });
+
+  let pkgJson = JSON.parse(fs.readFileSync(`${cwd}/package.json`, 'utf-8'));
+  let mgr = packageManager;
+  if (mgr.indexOf('npm') === 0) {
+    mgr = 'npm run';
+  }
+  pkgJson.name = applicationNameForPkg;
+  pkgJson.scripts = Object.fromEntries(
+    Object.entries(pkgJson.scripts || {}).map(([key, value]) => [key, value.replace(/~PACKAGE_MANAGER~/g, mgr)]),
+  );
+
+  // Get the framework version from package.json
+  const frameworkPkg = JSON.parse(fs.readFileSync(dist('package.json'), 'utf-8'));
+
+  // Set the caper dependency version
+  if (pkgJson.dependencies && pkgJson.dependencies['@caperjs/core']) {
+    pkgJson.dependencies['@caperjs/core'] = ensureCaretPrefix(frameworkPkg.version);
+  }
+
+  // Add framework peer dependencies to the template's peerDependencies
+  if (frameworkPkg.peerDependencies) {
+    if (!pkgJson.peerDependencies) {
+      pkgJson.peerDependencies = {};
+    }
+
+    // Add each peer dependency with its version
+    Object.entries(frameworkPkg.peerDependencies).forEach(([name, version]) => {
+      if (!pkgJson.peerDependencies[name]) {
+        pkgJson.peerDependencies[name] = ensureCaretPrefix(version);
+      }
+    });
+  }
+
+  // Write the initial package.json with template replacements
+  fs.writeFileSync(`${cwd}/package.json`, JSON.stringify(pkgJson, null, 2));
+
+  // find index.html and replace ~NAME~ with the application's origin al name
+  const index_file = `${cwd}/index.html`;
+  let index_contents = fs.readFileSync(index_file, 'utf-8');
+  index_contents = index_contents.replace(/~NAME~/g, defaultName);
+  fs.writeFileSync(index_file, index_contents, 'utf-8');
+
+  // find readme.md and replace ~NAME~ with the application's origin al name
+  const readme_file = `${cwd}/README.md`;
+  let readme_contents = fs.readFileSync(readme_file, 'utf-8');
+  readme_contents = readme_contents.replace(/~NAME~/g, defaultName);
+  readme_contents = readme_contents.replace(/~PACKAGE_MANAGER~/g, mgr);
+  fs.writeFileSync(readme_file, readme_contents, 'utf-8');
+
+  // find __APPLICATION_NAME__.ts and replace it with the application name, then delete ~Application.ts
+  const app_file = `${cwd}/src/__APPLICATION_NAME__.ts`;
+  const app_contents = fs.readFileSync(app_file, 'utf-8');
+  fs.writeFileSync(`${cwd}/src/${applicationName}.ts`, app_contents, 'utf-8');
+  fs.rmSync(app_file);
+
+  // recursively loop through all the .ts files in the src directory and replace __APPLICATION_NAME__ with the application name
+  const tsFiles = getFiles(`${cwd}/src`);
+  tsFiles.forEach((file) => {
+    const contents = fs.readFileSync(file.name, 'utf-8');
+    fs.writeFileSync(file.name, contents.replace(/__APPLICATION_NAME__/g, applicationName));
+  });
+
+  // Update caper.config.ts with selected plugins and storage adapters
+  const configPath = `${cwd}/caper.config.ts`;
+  let configContents = fs.readFileSync(configPath, 'utf-8');
+
+  if (plugins && plugins.length > 0) {
+    // Convert plugin names to config format
+    const pluginConfigs = plugins.map((pluginName) => {
+      // Remove @caperjs/plugin- prefix
+      const shortName = pluginName.replace('@caperjs/plugin-', '');
+      return `['${shortName}', { autoLoad: false }]`;
+    });
+
+    // Replace empty plugins array with configured plugins
+    configContents = configContents.replace(
+      /plugins:\s*\[\s*\]/,
+      `plugins: [\n    ${pluginConfigs.join(',\n    ')}\n  ]`,
+    );
+  }
+
+  fs.writeFileSync(configPath, configContents.replace(/__APPLICATION_NAME__/g, applicationName), 'utf-8');
+
+  // Add selected plugins to dependencies
+  if (plugins && plugins.length > 0) {
+    if (!pkgJson.dependencies) {
+      pkgJson.dependencies = {};
+    }
+
+    plugins.forEach((pluginName) => {
+      const plugin = AVAILABLE_PLUGINS.find((p) => p.name === pluginName);
+      if (plugin) {
+        // Use the framework version as the plugin version
+        pkgJson.dependencies[pluginName] = ensureCaretPrefix(frameworkPkg.version);
+      }
+    });
+  }
+
+  // Write the final package.json with all dependencies
+  fs.writeFileSync(`${cwd}/package.json`, JSON.stringify(pkgJson, null, 2));
+
+  try {
+    fs.rmSync(`${cwd}/.meta.json`);
+    fs.rmSync(`${cwd}/package.template.json`);
+    // create an .npmrc file with the following content:
+    // shamefully-hoist=true
+    fs.writeFileSync(`${cwd}/.npmrc`, 'shamefully-hoist=true');
+  } catch (e) {
+    console.log('Failed to remove .meta.json and package.template.json due to:', e);
+  }
+}
+
+export async function create(cwd = '.', packageManagerOverride) {
+  if (packageManagerOverride) {
+    packageManager = packageManagerOverride;
+  }
+  const dir = dist(``);
+  const pkg = JSON.parse(fs.readFileSync(`${dir}/package.json`, 'utf-8'));
+  p.intro(
+    `Caper Create (v${pkg.version}) - This utility will walk you through creating a new Caper project.`,
+  );
+
+  if (cwd === '.') {
+    const dir = await p.text({
+      message: 'Where should we create your project?',
+      placeholder: '(Enter to use current directory)',
+    });
+
+    if (p.isCancel(dir)) {
+      process.exit(1);
+    }
+
+    if (dir) {
+      cwd = /** @type {string} */ (dir);
+    }
+  }
+
+  if (fs.existsSync(cwd)) {
+    if (fs.readdirSync(cwd).length > 0) {
+      const force = await p.confirm({
+        message: 'Directory not empty. Continue?',
+        initialValue: false,
+      });
+
+      // bail if `force` is `false` or the user cancelled with Ctrl-C
+      if (force !== true) {
+        process.exit(1);
+      }
+    }
+  }
+
+  const options = await p.group({
+    template: () =>
+      p.select({
+        message: 'Which template?',
+        options: fs
+          .readdirSync(dist('templates/app'))
+          .map((dir) => {
+            const meta_file = dist(`templates/app/${dir}/.meta.json`);
+            const { title, description } = JSON.parse(fs.readFileSync(meta_file, 'utf8'));
+
+            return {
+              label: title,
+              hint: description,
+              value: `app/${dir}`,
+            };
+          })
+          .filter(Boolean),
+      }),
+    plugins: () =>
+      p.multiselect({
+        required: false,
+        message: 'Which plugins would you like to add (Enter to skip)?',
+        options: AVAILABLE_PLUGINS.map((plugin) => ({
+          label: `${plugin.displayName} - ${plugin.description}`,
+          value: plugin.name,
+        })),
+      }),
+  });
+
+  // get a name from the cwd provided
+  const name = path.basename(path.resolve(cwd));
+
+  const defaultName = name
+    .replace(/\s+/g, '-')
+    .replace('_', '-')
+    .toLowerCase()
+    .split('-')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+
+  // ask for a name if the user used "." or didn't provide one
+  let appName = await p.text({
+    message: 'What should we call your project?',
+    placeholder: `(Enter to use '${defaultName}')`,
+  });
+
+  if (!appName) {
+    appName = name;
+  }
+
+  // derive an application name from the project name by camel casing it
+  const applicationNameForPkg = appName.replace(/\s+/g, '-').replace('_', '-').toLowerCase();
+
+  const applicationName =
+    applicationNameForPkg.indexOf('-') === -1
+      ? appName
+      : applicationNameForPkg
+          .split('-')
+          .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+          .join('');
+
+  await write(cwd, {
+    name,
+    applicationNameForPkg,
+    applicationName,
+    defaultName,
+    template: /** @type {'default' | 'react'} */ (options.template),
+    plugins: options.plugins,
+  });
+
+  const s = p.spinner();
+  s.start(`Installing dependencies...`);
+  const exec = promisify(shell.exec);
+  await exec(`${packageManager} install`, { silent: true, cwd }).catch(() => ({ code: 1 }));
+  // const message = command.code === 0 ? 'Installtion successful' : 'Installation failed';
+  s.stop('Installation complete!');
+
+  let msg = `Next steps:`;
+  let i = 1;
+
+  const relative = path.relative(process.cwd(), cwd);
+  if (relative !== '') {
+    msg = `${msg}\n  ${i++}: ${bold(cyan(`cd ${relative}`))}`;
+  }
+
+  // prettier-ignore
+  msg = `${msg}\n  ${i++}: ${bold(cyan('git init && git add -A && git commit -m "Initial commit"'))} (optional)`;
+  msg = `${msg}\n  ${i++}: ${bold(cyan(`${package_manager} run dev`))}`;
+  msg = `${msg}\n  To close the dev server, hit ${bold(cyan('Ctrl-C'))}`;
+
+  p.outro(msg);
+}

package/cli/install-peerdeps.mjs

@@ -0,0 +1,57 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const cwd = process.cwd();
+/**
+ *
+ * @returns Promise<void>
+ */
+export async function installPeerDeps() {
+  // Read package.json to get peer dependencies
+  const caperPackageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8'));
+  const peerDependencies = caperPackageJson.peerDependencies;
+
+  if (!peerDependencies) {
+    console.log('No peer dependencies found.');
+    return 0;
+  }
+
+  const dependencies = Object.entries(peerDependencies)
+    .map(([dep, version]) => `${dep}@${version}`)
+    .join(' ');
+  const packageJson = JSON.parse(fs.readFileSync(path.resolve(cwd, 'package.json'), 'utf8'));
+  // Detect package manager
+  let packageManager;
+
+  // check for packageManager entry in package.json
+  if (packageJson.packageManager) {
+    if (packageJson.packageManager?.includes('yarn')) {
+      packageManager = 'yarn add';
+    } else if (packageJson.packageManager?.includes('pnpm')) {
+      packageManager = 'pnpm add';
+    } else if (packageJson.packageManager?.includes('npm')) {
+      packageManager = 'npm install';
+    }
+  }
+  if (!packageManager) {
+    if (fs.existsSync(path.resolve(cwd, 'yarn.lock'))) {
+      packageManager = 'yarn add';
+    } else if (fs.existsSync(path.resolve(cwd, 'pnpm-lock.yaml'))) {
+      packageManager = 'pnpm add';
+    } else if (fs.existsSync(path.resolve(cwd, 'package-lock.json'))) {
+      packageManager = 'npm install';
+    } else {
+      console.log('No lockfile detected. Defaulting to npm.');
+      packageManager = 'npm install';
+    }
+  }
+
+  // Install peer dependencies
+  console.log(`Installing peer dependencies using ${packageManager}`);
+  return execSync(`${packageManager} ${dependencies}`, { stdio: 'inherit' });
+}

package/cli/update.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {execSync} from 'node:child_process';
+import {package_manager} from './utils.mjs';
+
+const install_path = 'github:anthonysapp/caper';
+
+export async function update() {
+	return execSync(`${package_manager} install ${install_path}`);
+}

package/cli/utils.mjs

@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** @param {string} dir */
+export function mkdirp(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch (e) {
+    if (/** @type {any} */ (e).code === 'EEXIST') {
+      return;
+    }
+    throw e;
+  }
+}
+
+/** @param {string} path */
+export function rimraf(path) {
+  (fs.rmSync || fs.rmdirSync)(path, { recursive: true, force: true });
+}
+
+/**
+ * @template T
+ * @param {T} x
+ */
+function identity(x) {
+  return x;
+}
+
+/**
+ * @param {string} from
+ * @param {string} to
+ * @param {(basename: string) => string} rename
+ */
+export function copy(from, to, rename = identity) {
+  if (!fs.existsSync(from)) {
+    return;
+  }
+
+  const stats = fs.statSync(from);
+
+  if (stats.isDirectory()) {
+    fs.readdirSync(from).forEach((file) => {
+      copy(path.join(from, file), path.join(to, rename(file)));
+    });
+  } else {
+    mkdirp(path.dirname(to));
+    fs.copyFileSync(from, to);
+  }
+}
+
+/** @param {string} path */
+export function dist(path) {
+  return fileURLToPath(new URL(`../${path}`, import.meta.url).href);
+}
+
+/** @type {string} */
+export const package_manager = get_package_manager() || 'npm';
+
+/**
+ * Supports npm, pnpm, Yarn, cnpm, bun and any other package manager that sets the
+ * npm_config_user_agent env variable.
+ * Thanks to https://github.com/zkochan/packages/tree/main/which-pm-runs for this code!
+ */
+function get_package_manager() {
+  // add clauses for --use-pnpm and --use-yarn
+  if (process.argv.includes('--use-pnpm')) {
+    return 'pnpm';
+  }
+  if (process.argv.includes('--use-yarn')) {
+    return 'yarn';
+  }
+  if (!process.env.npm_config_user_agent) {
+    return undefined;
+  }
+  const user_agent = process.env.npm_config_user_agent;
+  const pm_spec = user_agent.split(' ')[0];
+  const separator_pos = pm_spec.lastIndexOf('/');
+  const name = pm_spec.substring(0, separator_pos);
+  return name === 'npminstall' ? 'cnpm' : name;
+}

package/cli/vite.mjs

@@ -0,0 +1,55 @@
+import { build, createServer, loadConfigFromFile, mergeConfig, preview } from 'vite';
+import { defaultConfig } from '../config/vite.mjs';
+
+async function getMergedViteConfig(command, mode) {
+  // Load user's vite.config.js file if it exists
+  const userConfig = await loadConfigFromFile({
+    command,
+    mode,
+  });
+
+  // Merge user config with default config
+  const mergedConfig = mergeConfig(defaultConfig, userConfig?.config || {});
+
+  // Remove duplicate plugins by name, preferring user's config over default, while preserving order.
+  if (mergedConfig.plugins) {
+    const seen = new Set();
+    mergedConfig.plugins = mergedConfig.plugins
+      .flat()
+      .reverse()
+      .filter((plugin) => {
+        if (!plugin || !plugin.name) {
+          // Keep plugins without a name (e.g., some Vite internal plugins)
+          return true;
+        }
+        if (seen.has(plugin.name)) {
+          return false;
+        }
+        seen.add(plugin.name);
+        return true;
+      })
+      .reverse();
+  }
+
+  return mergedConfig;
+}
+
+export async function startDevServer() {
+  const config = await getMergedViteConfig('serve', 'development');
+  const server = await createServer(config);
+  await server.listen();
+
+  server.printUrls();
+}
+
+export async function runBuild() {
+  const config = await getMergedViteConfig('build', 'production');
+  await build(config);
+}
+
+export async function runPreview() {
+  const config = await getMergedViteConfig('build', 'production');
+  await build(config);
+  const server = await preview(config);
+  server.printUrls();
+}