ember.nvp 0.0.0 → 0.2.0

package/src/cli/generator.js

@@ -0,0 +1,74 @@
+import { mkdir } from "node:fs/promises";
+
+import baseApp from "#bases/minimal-app";
+import baseLibrary from "#bases/minimal-library";
+import { consolidateLintingScripts } from "../consolidators/linting.js";
+import { hasGit } from "#utils/git.js";
+/**
+ * Generate project files by running layer functions
+ *
+ * @param {import('#utils/project.js').Project} project
+ */
+export async function generateProject(project) {
+  await mkdir(project.directory, { recursive: true });
+
+  switch (project.desires.type) {
+    case "app":
+      await baseApp.run(project);
+      break;
+    case "library":
+      await baseLibrary.run(project);
+      break;
+  }
+
+  /**
+   * We could run these in a loop until there is no git diff
+   */
+  await runLap(project);
+
+  if (hasGit(project.directory)) {
+    await project.gitAdd();
+
+    if (await project.gitHasDiff()) {
+      let layerNames = project.desires.layers.map((l) => l.name).join(", ");
+      await project.gitCommit(
+        `[ember.nvp] Applied ${layerNames} to ${project.type}: ${project.name} -- Please report issues to https://github.com/NullVoxPopuli/ember.nvp/`,
+      );
+    }
+  }
+
+  await runLap(project);
+
+  if (hasGit(project.directory) && (await project.gitHasDiff())) {
+    await project.gitAdd();
+    await project.gitCommit(
+      `[ember.nvp] Consolidation commit -- Please report issues to https://github.com/NullVoxPopuli/ember.nvp/`,
+    );
+  }
+
+  await runLap(project);
+
+  if (hasGit(project.directory) && (await project.gitHasDiff())) {
+    await project.gitAdd();
+    await project.gitCommit(
+      `[ember.nvp] Consolidation commit -- Please report issues to https://github.com/NullVoxPopuli/ember.nvp/`,
+    );
+  }
+}
+
+/**
+ *
+ * @param {import('#utils/project.js').Project} project
+ */
+async function runLap(project) {
+  for (const layer of project.desires.layers) {
+    if (typeof layer.run !== "function") {
+      console.warn(`${layer.name} is not implemented`);
+      continue;
+    }
+
+    await layer.run(project);
+  }
+
+  await consolidateLintingScripts(project);
+}

package/src/cli/index.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import * as p from "@clack/prompts";
+import { generateProject } from "./generator.js";
+import { askName } from "./questions/name.js";
+import { askLayers } from "./questions/layers.js";
+import { askProjectType } from "./questions/project-type.js";
+import { askPackageManager } from "./questions/package-manager.js";
+import { askPath } from "./questions/path.js";
+import { askIfOK } from "./questions/ok.js";
+import { styleText } from "node:util";
+import { Project } from "#utils/project.js";
+
+/**
+ * This whole file's primary purpose is to be an interactive CLI
+ * for `generateProject`.
+ *
+ * Other tools can call `generateProject` themselves if they wish
+ * if they want to provide different TUI/GUIs.
+ */
+async function main() {
+  console.clear();
+
+  p.intro(styleText(["bgCyan", "black"], " ember.nvp "));
+
+  const projectName = await askName();
+  const projectPath = await askPath(projectName);
+  const projectType = await askProjectType();
+  const selectedLayers = await askLayers();
+  const packageManager = await askPackageManager();
+
+  let project = new Project(projectPath, {
+    name: projectName,
+    type: projectType,
+    path: projectPath,
+    layers: selectedLayers,
+    packageManager,
+  });
+
+  await askIfOK();
+
+  const s = p.spinner();
+  s.start("Creating your Ember app...");
+
+  try {
+    // Generate the project
+    await generateProject(project);
+
+    s.stop("Project created!");
+
+    p.note(
+      `cd ${projectName}\n` +
+        `${packageManager} install\n` +
+        `${packageManager} ${packageManager === "npm" ? "run " : ""}start`,
+      "Next steps",
+    );
+
+    p.outro(styleText("green", "✓") + " Project ready! " + styleText("dim", "Happy coding!"));
+  } catch (err) {
+    s.stop("Failed to create project");
+
+    if (err instanceof Error) {
+      p.cancel(`Error: ${err.message}`);
+      if (err.stack) {
+        console.error(err.stack);
+      }
+
+      process.exit(1);
+    }
+
+    p.cancel(`Error: ${String(err)}`);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/cli/questions/layers.js

@@ -0,0 +1,64 @@
+import { answers, printArgInUse } from "#args";
+import { discoverLayers } from "#layers";
+
+import * as p from "@clack/prompts";
+
+export async function askLayers() {
+  const optionalLayers = (await discoverLayers()).filter(
+    (layer) => typeof layer.run === "function",
+  );
+
+  const supported = new Set(optionalLayers.map((layer) => layer.name));
+
+  /**
+   *
+   * @param {string[] | undefined} selected
+   * @returns {selected is string[]}
+   */
+  function isValid(selected) {
+    if (!selected) return false;
+    if (Array.isArray(selected) && selected.length === 0) return false;
+
+    return selected.every((name) => supported.has(name));
+  }
+
+  if (isValid(answers.layers)) {
+    let result = optionalLayers.filter((layer) => answers.layers.includes(layer.name));
+
+    printArgInUse(`layers`, result.map((layer) => layer.name).join(", "));
+
+    return result;
+  }
+
+  // Whenever we have a yes/no option, we use string values rather than true/false
+  const defaultValues = (
+    await Promise.all(
+      optionalLayers.map(async (layer) => {
+        let result = await layer.defaultValue?.();
+
+        return result && layer.name;
+      }),
+    )
+  ).filter(Boolean);
+
+  const selectedFeatures = await p.multiselect({
+    message: "Select additional features:",
+    initialValues: defaultValues,
+    options: optionalLayers.map((layer) => ({
+      value: layer.name,
+      label: layer.label ?? layer.name,
+      hint: layer.hint,
+    })),
+    required: false,
+  });
+
+  if (p.isCancel(selectedFeatures)) {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  // Build the final configuration
+  const selectedLayers = optionalLayers.filter((layer) => selectedFeatures.includes(layer.name));
+
+  return selectedLayers;
+}

package/src/cli/questions/name.js

@@ -0,0 +1,38 @@
+import * as p from "@clack/prompts";
+
+import packageNameRegex from "package-name-regex";
+import { answers, printArgInUse } from "#args";
+
+const DEFAULT = "my-app";
+
+export async function askName() {
+  if (answers.name) {
+    let isValid = packageNameRegex.test(answers.name);
+    if (isValid) {
+      printArgInUse("name", answers.name);
+
+      return answers.name;
+    }
+  }
+  const projectName = await p.text({
+    message: "What is your project name?",
+    placeholder: DEFAULT,
+    defaultValue: DEFAULT,
+    validate(value) {
+      if (value.length === 0) return;
+
+      let isValid = packageNameRegex.test(value);
+
+      if (!isValid) {
+        return "Project name must be a valid npm package-name";
+      }
+    },
+  });
+
+  if (p.isCancel(projectName)) {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  return projectName ?? DEFAULT;
+}

package/src/cli/questions/ok.js

@@ -0,0 +1,38 @@
+import * as p from "@clack/prompts";
+import { answers, printArgInUse } from "#args";
+
+const SUPPORTED = new Set(["yes", "no"]);
+
+/**
+ *
+ * @param {string | undefined} selected
+ * @returns {selected is 'yes' | 'no'}
+ */
+function isValid(selected) {
+  if (!selected) return false;
+
+  return SUPPORTED.has(selected);
+}
+
+export async function askIfOK() {
+  if (isValid(answers.confirm)) {
+    printArgInUse("confirm", answers.confirm);
+
+    return answers.confirm;
+  }
+
+  const answer = await p.select({
+    message: "Do all the selections above look ok?",
+    options: [
+      { value: "yes", label: "yes, generate the project" },
+      { value: "no", label: "no, cancel" },
+    ],
+  });
+
+  if (p.isCancel(answer) || answer === "no") {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  return answer;
+}

package/src/cli/questions/package-manager.js

@@ -0,0 +1,42 @@
+import * as p from "@clack/prompts";
+import { answers, printArgInUse } from "#args";
+
+const SUPPORTED = new Set(["pnpm", "npm"]);
+
+/**
+ *
+ * @param {string | undefined} selected
+ * @returns {selected is 'pnpm' | 'npm'}
+ */
+function isValid(selected) {
+  if (!selected) return false;
+
+  return SUPPORTED.has(selected);
+}
+
+/**
+ *
+ * @returns {Promise<import('#types').PackageManager>}
+ */
+export async function askPackageManager() {
+  if (isValid(answers.packageManager)) {
+    printArgInUse("packageManager", answers.packageManager);
+
+    return answers.packageManager;
+  }
+
+  const packageManager = await p.select({
+    message: "Which package manager?",
+    options: [
+      { value: "pnpm", label: "pnpm", hint: "Fast, disk space efficient" },
+      { value: "npm", label: "npm", hint: "Node default" },
+    ],
+  });
+
+  if (p.isCancel(packageManager)) {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  return packageManager;
+}

package/src/cli/questions/path.js

@@ -0,0 +1,59 @@
+import * as p from "@clack/prompts";
+
+import { join } from "node:path";
+import { answers, printArgInUse } from "#args";
+import { cwd } from "#utils/cwd.js";
+
+/**
+ *
+ * @param {string | undefined} value
+ * @returns
+ */
+function isValid(value) {
+  if (!value) return false;
+
+  return value.startsWith(".") || value.startsWith("/");
+}
+
+/**
+ * @param {string} name -- the projectName
+ */
+export async function askPath(name) {
+  if (answers.path) {
+    if (isValid(answers.path)) {
+      printArgInUse("path", answers.path);
+
+      return answers.path;
+    }
+  }
+
+  const defaultValue = join(cwd, name);
+
+  const answer = await p.text({
+    message: "Where would you like to place your project?",
+    placeholder: defaultValue.replace(cwd, "."),
+    defaultValue: defaultValue,
+    validate(value) {
+      if (value.length === 0) return;
+
+      if (!isValid(value)) {
+        return `Path must start with a '.' or '/' (be either a relative or absolute path)`;
+      }
+    },
+  });
+
+  if (p.isCancel(answer)) {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  if (answer) {
+    if (answer.startsWith(".")) {
+      return join(cwd, answer);
+    }
+
+    return answer;
+  }
+
+  return defaultValue;
+}

package/src/cli/questions/project-type.js

@@ -0,0 +1,55 @@
+import * as p from "@clack/prompts";
+import { answers, printArgInUse } from "#args";
+
+/**
+ * addon is alias for library
+ */
+const SUPPORTED = new Set(["app", "library", "addon"]);
+
+/**
+ * @param {string | undefined} selected
+ * @returns {selected is "app" | "library" | "addon"}
+ */
+function isValid(selected) {
+  if (!selected) return false;
+
+  return SUPPORTED.has(selected);
+}
+
+/**
+ *
+ * @return {Promise<import('#types').ProjectType>}
+ */
+export async function askProjectType() {
+  if (isValid(answers.type)) {
+    printArgInUse("type", answers.type);
+
+    if (answers.type === "addon") return "library";
+
+    return answers.type;
+  }
+
+  const answer = await p.select({
+    message: "Which type of project?",
+    options: [
+      { value: "app", label: "web app", hint: "generates html, js, and css to deploy to the web" },
+      {
+        value: "library",
+        label: "library",
+        hint: "sharable code, usable by other libraries and apps alike",
+      },
+    ],
+  });
+
+  if (answer === "library") {
+    p.cancel("Not implemented yet, apologies!");
+    return process.exit(0);
+  }
+
+  if (p.isCancel(answer)) {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  return answer;
+}

package/src/consolidators/linting.js

@@ -0,0 +1,51 @@
+import { getLatest } from "#utils/npm.js";
+import { packageJson } from "ember-apply";
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export async function consolidateLintingScripts(project) {
+  // todo
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export async function maybeLintWithConcurrently(project) {
+  /** @type {Record<string, boolean>} */
+  let linting = {
+    prettier: false,
+    eslint: false,
+    "ember-template-lint": false,
+    stylelint: false,
+  };
+
+  let count = 0;
+  let manifest = await packageJson.read(project.directory);
+
+  for (let script of Object.values(manifest.scripts)) {
+    for (let bin of Object.keys(linting)) {
+      if (script.includes(bin)) {
+        linting[bin] = true;
+        count++;
+      }
+    }
+  }
+
+  if (count > 1) {
+    await packageJson.modify(async (json) => {
+      json.scripts ||= {};
+      json.devDependencies ||= {};
+      json.scripts.lint = 'concurrently "pnpm:lint:*(!fix)" --names "lint:" --prefixColors auto';
+      json.scripts["lint:fix"] =
+        'concurrently "pnpm:lint:*:fix" --names "fix:" --prefixColors auto && pnpm format';
+
+      Object.assign(
+        json.devDependencies,
+        await getLatest({
+          concurrently: "^9.2.1",
+        }),
+      );
+    }, project.directory);
+  }
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export { generateProject } from "./cli/generator.js";
+export { Project } from "./utils/project.js";

package/src/layers/eslint-bundled-ember/files/eslint.config.js

@@ -0,0 +1,14 @@
+/**
+ * This tries to follow what the official blueprints are doing more closely
+ * but in a way that abstracts the dependencies and configuration
+ * out of your project.
+ *
+ * Handles: (G)TS + (G)JS, QUnit, Supporting Node files
+ */
+import { ember } from "ember-eslint";
+
+export default [
+  ...ember.recommended(import.meta.dirname),
+  // your modifications here
+  // see: https://eslint.org/docs/user-guide/configuring/configuration-files#how-do-overrides-work
+];

package/src/layers/eslint-bundled-ember/index.js

@@ -0,0 +1,91 @@
+import { getLatest } from "#utils/npm.js";
+import { files, packageJson } from "ember-apply";
+import { formatLabel } from "#utils/cli.js";
+import { maybeLintWithConcurrently } from "#consolidators/linting.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { hasDevDeps } from "#utils/manifest.js";
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: formatLabel("ESLint", "ember's encapsulated config"),
+  hint: `Minimal dependencies added to package.json. Not official, but follows the official configuration`,
+
+  async run(project) {
+    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
+
+    await packageJson.addDevDependencies(
+      await getLatest({
+        "ember-eslint": "^0.6.1",
+        eslint: "^9.39.2",
+      }),
+      project.directory,
+    );
+
+    await packageJson.addScripts(
+      {
+        "lint:eslint": "eslint . --cache",
+        "lint:eslint:fix": "eslint . --fix",
+      },
+      project.directory,
+    );
+
+    await maybeLintWithConcurrently(project);
+  },
+
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {true} explain
+   * @returns {Promise<{ isSetup: boolean; reasons: string[] }>}
+   */
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {boolean | undefined} [explain]
+   * @returns {Promise<boolean>}
+   */
+  async isSetup(project, explain) {
+    const reasons = [];
+
+    if (!existsSync(join(project.directory, "eslint.config.js"))) {
+      reasons.push("eslint.config.js is missing");
+
+      if (!explain) return false;
+    }
+
+    let manifest = await packageJson.read(project.directory);
+
+    if (!hasDevDeps(manifest, ["ember-eslint", "eslint"])) {
+      reasons.push("missing required dependencies: ember-eslint, eslint");
+
+      if (!explain) return false;
+    }
+
+    let scripts = Object.values(manifest.scripts ?? {}).filter((script) =>
+      script.includes("eslint"),
+    );
+
+    if (!scripts.some((script) => script.includes("--cache"))) {
+      reasons.push("missing eslint script with --cache flag");
+
+      if (!explain) return false;
+    }
+    if (!scripts.some((script) => script.includes("--fix"))) {
+      reasons.push("missing eslint script with --fix flag");
+
+      if (!explain) return false;
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};