@jsenv/cli 0.0.3 → 0.0.6

package/README.md

@@ -0,0 +1,7 @@
+# @jsenv/cli [![npm package](https://img.shields.io/npm/v/@jsenv/cli.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/cli)
+
+_@jsenv/cli_ is a NPM package meant to run via the command below:
+
+```console
+npx @jsenv/cli
+```

package/jsenv_cli.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+
+// see https://docs.npmjs.com/cli/v8/commands/npm-init#description
+
+import {
+  existsSync,
+  readdirSync,
+  mkdirSync,
+  statSync,
+  writeFileSync,
+  readFileSync,
+} from "node:fs";
+import { relative } from "node:path";
+import { parseArgs } from "node:util";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+import prompts from "prompts";
+import { createTaskLog, UNICODE } from "@jsenv/humanize";
+import { urlToRelativeUrl, ensurePathnameTrailingSlash } from "@jsenv/urls";
+
+// not using readdir to control order
+const availableTemplateNameArray = [
+  "web",
+  "web-components",
+  "web-react",
+  "web-preact",
+  "node-package",
+];
+const options = {
+  help: {
+    type: "boolean",
+  },
+  web: {
+    type: "boolean",
+  },
+  ["web-components"]: {
+    type: "boolean",
+  },
+  ["web-react"]: {
+    type: "boolean",
+  },
+  ["web-preact"]: {
+    type: "boolean",
+  },
+  ["node-package"]: {
+    type: "boolean",
+  },
+};
+const { values, positionals } = parseArgs({
+  options,
+  allowPositionals: true,
+});
+if (values.help) {
+  console.log(`@jsenv/cli: Init jsenv in a directory.
+
+Usage: npx @jsenv/cli <dir> [options]
+
+https://github.com/jsenv/core/tree/main/packages/related/cli
+
+<dir> Where to install jsenv files; Otherwise you'll be prompted to select.
+
+Options:
+  --help             Display this message.
+  --web              Consider directory as "web" project; Otherwise you'll be prompted to select.
+  --web-components   Consider directory as "web-components" project; Otherwise you'll be prompted to select.
+  --web-react        Consider directory as "web-react" project; Otherwise you'll be prompted to select.
+  --web-preact       Consider directory as "web-preact" project; Otherwise you'll be prompted to select.
+  --node-package     Consider directory as "node-package" project; Otherwise you'll be prompted to select.
+`);
+  process.exit(0);
+}
+
+console.log("Welcome in jsenv CLI");
+const commands = [];
+const cwdUrl = ensurePathnameTrailingSlash(pathToFileURL(process.cwd()));
+let directoryUrl;
+dir: {
+  const directoryPathFromArg = positionals[0];
+  if (directoryPathFromArg) {
+    directoryUrl = ensurePathnameTrailingSlash(
+      new URL(directoryPathFromArg, cwdUrl),
+    );
+    console.log(`${UNICODE.OK} Enter a directory: ${directoryPathFromArg}`);
+    break dir;
+  }
+  const result = await prompts(
+    {
+      type: "text",
+      name: "directory",
+      message: "Enter a directory:",
+    },
+    {
+      onCancel: () => {
+        console.log("Aborted, can be resumed any time");
+        process.exit(0);
+      },
+    },
+  );
+  directoryUrl = ensurePathnameTrailingSlash(new URL(result.directory, cwdUrl));
+}
+if (directoryUrl.href !== cwdUrl.href) {
+  const dir = relative(fileURLToPath(cwdUrl), fileURLToPath(directoryUrl));
+  commands.push({
+    label: `cd ${dir}`,
+    run: () => {
+      process.chdir(dir);
+    },
+  });
+}
+let templateName;
+template: {
+  const templateNameFromArg = availableTemplateNameArray.find(
+    (availableTemplateName) => values[availableTemplateName],
+  );
+  if (templateNameFromArg) {
+    templateName = templateNameFromArg;
+    console.log(`${UNICODE.OK} Select a template: ${templateNameFromArg}`);
+    break template;
+  }
+  const result = await prompts(
+    [
+      {
+        type: "select",
+        name: "templateName",
+        message: "Select a template:",
+        initial: 0,
+        choices: availableTemplateNameArray.map((availableTemplateName) => {
+          return {
+            title: availableTemplateName,
+            value: availableTemplateName,
+          };
+        }),
+      },
+    ],
+    {
+      onCancel: () => {
+        console.log("Aborted, can be resumed any time");
+        process.exit(0);
+      },
+    },
+  );
+  templateName = result.templateName;
+}
+
+write_files: {
+  const writeFilesTask = createTaskLog(`init jsenv in "${directoryUrl}"`);
+  const mergeTwoIgnoreFileContents = (left, right) => {
+    const leftLines = String(left)
+      .split("\n")
+      .map((l) => l.trim());
+    const rightLines = String(right)
+      .split("\n")
+      .map((l) => l.trim());
+    let finalContent = left;
+    for (const rightLine of rightLines) {
+      if (!leftLines.includes(rightLine)) {
+        finalContent += "\n";
+        finalContent += rightLine;
+      }
+    }
+    return finalContent;
+  };
+  const overrideHandlers = {
+    "package.json": (existingContent, templateContent) => {
+      const existingPackage = JSON.parse(existingContent);
+      const templatePackage = JSON.parse(templateContent);
+      const override = (left, right, allowedKeys) => {
+        if (right === null) {
+          return left === undefined ? null : left;
+        }
+        if (Array.isArray(right)) {
+          if (Array.isArray(left)) {
+            for (const valueFromRight of right) {
+              if (!left.includes(valueFromRight)) {
+                left.push(valueFromRight);
+              }
+            }
+            return left;
+          }
+          return left === undefined ? right : left;
+        }
+        if (typeof right === "object") {
+          if (left && typeof left === "object") {
+            const keysToVisit = allowedKeys || Object.keys(right);
+            for (const keyToVisit of keysToVisit) {
+              const rightValue = right[keyToVisit];
+              if (rightValue === undefined) {
+                continue;
+              }
+              const leftValue = left[keyToVisit];
+              left[keyToVisit] = override(leftValue, rightValue);
+            }
+            return left;
+          }
+          return left === undefined ? right : left;
+        }
+        return left === undefined ? right : left;
+      };
+      const existingDependencies = existingPackage.dependencies
+        ? { ...existingPackage.dependencies }
+        : {};
+      const existingDevDependencies = existingPackage.devDependencies
+        ? { ...existingPackage.devDependencies }
+        : {};
+      override(existingPackage, templatePackage, [
+        "scripts",
+        "dependencies",
+        "devDependencies",
+      ]);
+      const finalDependencies = existingPackage.dependencies || {};
+      const finalDevDependencies = existingPackage.devDependencies || {};
+      if (
+        JSON.stringify(existingDependencies) !==
+          JSON.stringify(finalDependencies) ||
+        JSON.stringify(existingDevDependencies) !==
+          JSON.stringify(finalDevDependencies)
+      ) {
+        commands.push({
+          label: "npm install",
+          run: () => {
+            console.log("npm install");
+            execSync("npm install", {
+              stdio: [0, 1, 2],
+            });
+          },
+        });
+      }
+      if (existingContent.startsWith("{\n")) {
+        return JSON.stringify(existingPackage, null, "  ");
+      }
+      return JSON.stringify(existingPackage);
+    },
+    ".gitignore": mergeTwoIgnoreFileContents,
+    ".eslintignore": mergeTwoIgnoreFileContents,
+  };
+  const templateSourceDirectoryUrl = new URL(
+    `./template-${templateName}/`,
+    import.meta.url,
+  );
+  const copyDirectoryContent = (fromDirectoryUrl, toDirectoryUrl) => {
+    if (!existsSync(toDirectoryUrl)) {
+      mkdirSync(toDirectoryUrl, { recursive: true });
+    }
+    const directoryEntryNameArray = readdirSync(fromDirectoryUrl);
+    for (const directoryEntryName of directoryEntryNameArray) {
+      if (
+        directoryEntryName === ".jsenv" ||
+        directoryEntryName === "dist" ||
+        directoryEntryName === "node_modules"
+      ) {
+        continue;
+      }
+      const fromUrl = new URL(directoryEntryName, fromDirectoryUrl);
+      const toUrl = new URL(
+        directoryEntryName === "_gitignore" ? ".gitignore" : directoryEntryName,
+        toDirectoryUrl,
+      );
+      const fromStat = statSync(fromUrl);
+      if (fromStat.isDirectory()) {
+        if (directoryEntryName === "src" || directoryEntryName === "tests") {
+          // copy src and tests if they don't exists
+          if (existsSync(toUrl)) {
+            continue;
+          }
+          // for web the presence of index.html or main.html at the root
+          // prevent src/ content from being copied
+          if (templateName.startsWith("web")) {
+            if (existsSync(new URL("./index.html", directoryUrl))) {
+              continue;
+            }
+            if (existsSync(new URL("./main.html", directoryUrl))) {
+              continue;
+            }
+          }
+        }
+        copyDirectoryContent(
+          ensurePathnameTrailingSlash(fromUrl),
+          ensurePathnameTrailingSlash(toUrl),
+        );
+        continue;
+      }
+      if (!existsSync(toUrl)) {
+        if (directoryEntryName === "package.json") {
+          commands.push({
+            label: "npm install",
+            run: () => {
+              console.log("npm install");
+              execSync("npm install", {
+                stdio: [0, 1, 2],
+              });
+            },
+          });
+        }
+        writeFileSync(toUrl, readFileSync(fromUrl));
+        continue;
+      }
+      const relativeUrl = urlToRelativeUrl(fromUrl, templateSourceDirectoryUrl);
+      const overrideHandler = overrideHandlers[relativeUrl];
+      if (!overrideHandler) {
+        // when there is no handler the file is kept as is
+        continue;
+      }
+      const existingContent = readFileSync(toUrl);
+      const templateContent = readFileSync(fromUrl);
+      const finalContent = overrideHandler(
+        String(existingContent),
+        String(templateContent),
+      );
+      writeFileSync(toUrl, finalContent);
+    }
+  };
+  copyDirectoryContent(
+    new URL(templateSourceDirectoryUrl),
+    new URL(directoryUrl),
+  );
+  writeFilesTask.done();
+}
+
+run_commands: {
+  if (commands.length === 0) {
+    break run_commands;
+  }
+  let message;
+  if (commands.length === 1) {
+    console.log(`----- 1 command to run -----
+${commands[0].label}
+---------------------------`);
+    // we can't run cd for the parent terminal
+    // so we'll just print the command in that case
+    // and user will have to run it if he want to go into the
+    // directory
+    if (commands[0].label.startsWith("cd")) {
+      console.log("Done, thank you");
+      process.exit(0);
+    }
+    message = "Can we run the command";
+  } else {
+    console.log(`----- ${commands.length} commands to run -----
+${commands.map((c) => c.label).join("\n")}
+-----------------------------`);
+    message = "Can we run the commands";
+  }
+  const { value } = await prompts({
+    type: "confirm",
+    name: "value",
+    message,
+    initial: true,
+  });
+  if (!value) {
+    console.log("Done, thank you");
+    process.exit(0);
+  }
+  for (const command of commands) {
+    await command.run();
+  }
+  console.log("Done, thank you");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/cli",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "Command Line Interface for jsenv",
   "license": "MIT",
   "repository": {
@@ -20,13 +20,15 @@
   },
   "type": "module",
   "bin": {
-    "jsenv": "src/jsenv_cli.mjs"
+    "jsenv": "jsenv_cli.js"
   },
   "files": [
-    "./src/"
+    "./jsenv_cli.js",
+    "./template-*/**"
   ],
   "dependencies": {
-    "prompts": "2.4.2",
-    "@jsenv/humanize": "1.2.4"
+    "@jsenv/humanize": "1.2.4",
+    "@jsenv/urls": "2.3.0",
+    "prompts": "2.4.2"
   }
 }

package/template-node-package/.eslintignore

@@ -0,0 +1,2 @@
+.jsenv/
+.coverage/

package/template-node-package/.eslintrc.cjs

@@ -0,0 +1,102 @@
+/*
+ * This file uses "@jsenv/eslint-config" to configure ESLint
+ * See https://github.com/jsenv/eslint-config#eslint-config----
+ */
+
+const {
+  composeEslintConfig,
+  eslintConfigBase,
+  eslintConfigForPrettier,
+  eslintConfigToPreferExplicitGlobals,
+  jsenvEslintRules,
+  jsenvEslintRulesForImport,
+} = require("@jsenv/eslint-config");
+
+const eslintConfig = composeEslintConfig(
+  eslintConfigBase,
+
+  // enable top level await
+  {
+    parserOptions: {
+      ecmaVersion: 2022,
+    },
+  },
+
+  // Files in this repository are all meant to be executed in Node.js
+  // and we want to tell this to ESLint.
+  // As a result ESLint can consider `window` as undefined
+  // and `global` as an existing global variable.
+  {
+    env: {
+      node: true,
+    },
+  },
+
+  // Reuse jsenv eslint rules
+  {
+    rules: {
+      ...jsenvEslintRules,
+      // Example of code changing the ESLint configuration to enable a rule:
+      // 'prefer-const':  ['error']
+    },
+  },
+
+  // Enable import plugin
+  {
+    plugins: ["import"],
+    settings: {
+      "import/resolver": {
+        "@jsenv/eslint-import-resolver": {
+          rootDirectoryUrl: __dirname,
+          packageConditions: ["node", "import"],
+        },
+      },
+      "import/extensions": [".js", ".mjs"],
+    },
+    rules: jsenvEslintRulesForImport,
+  },
+
+  // package is "type": "module" so:
+  // 1. disable commonjs globals by default
+  // 2. Re-enable commonjs into *.cjs files
+  {
+    globals: {
+      __filename: "off",
+      __dirname: "off",
+      require: "off",
+      exports: "off",
+    },
+    overrides: [
+      {
+        files: ["**/*.cjs"],
+        env: {
+          commonjs: true,
+        },
+        // inside *.cjs files. restore commonJS "globals"
+        globals: {
+          __filename: true,
+          __dirname: true,
+          require: true,
+          exports: true,
+        },
+        // inside *.cjs files, use commonjs module resolution
+        settings: {
+          "import/resolver": {
+            "@jsenv/eslint-import-resolver": {
+              rootDirectoryUrl: __dirname,
+              packageConditions: ["node", "require"],
+            },
+          },
+        },
+      },
+    ],
+  },
+
+  eslintConfigToPreferExplicitGlobals,
+
+  // We are using prettier, disable all eslint rules
+  // already handled by prettier.
+  eslintConfigForPrettier,
+);
+
+module.exports = eslintConfig;

package/template-node-package/.jsenv/jsenv_tests_output.txt

@@ -0,0 +1,8 @@
+------------- 1 execution ready -------------
+directory: /Users/damien.maillard/dev/perso/jsenv-core/packages/related/create-jsenv/demo-node-package
+---------------------------------------------
+✔ 1/1 tests/message.test.mjs [0.02s] (all completed)
+------------- 1 execution done --------------
+status: all completed
+duration: 0.1s (setup: 0.004s, execution: 0.1s, teardown: 0s)
+---------------------------------------------

package/template-node-package/.prettierrc.yml

@@ -0,0 +1,2 @@
+trailingComma: "all"
+quoteProps: "consistent"

package/template-node-package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "jsenv-template-node-package",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/main.js"
+  },
+  "scripts": {
+    "test": "node ./scripts/test.mjs",
+    "test:coverage": "npm run test -- --coverage"
+  },
+  "devDependencies": {
+    "@jsenv/assert": "4.1.4",
+    "@jsenv/core": "39.2.1",
+    "@jsenv/eslint-config": "16.5.2",
+    "@jsenv/eslint-import-resolver": "8.1.2",
+    "@jsenv/test": "3.3.11",
+    "eslint": "8.56.0",
+    "eslint-plugin-import": "2.29.1",
+    "prettier": "3.3.3"
+  }
+}

package/template-node-package/scripts/test.mjs

@@ -0,0 +1,25 @@
+/*
+ * Execute all test files
+ * - npm test
+ * - npm test:coverage
+ * Read more in https://github.com/jsenv/core/tree/main/packages/test#jsenvtest-
+ */
+
+import { executeTestPlan, nodeWorkerThread } from "@jsenv/test";
+
+await executeTestPlan({
+  rootDirectoryUrl: new URL("../", import.meta.url),
+  testPlan: {
+    "./tests/**/*.test.mjs": {
+      node: {
+        runtime: nodeWorkerThread(),
+      },
+    },
+  },
+  coverage: process.argv.includes("--coverage")
+    ? {
+        methodForNodeJs: "Profiler",
+      }
+    : false,
+  githubCheck: false,
+});

package/template-node-package/src/main.js

@@ -0,0 +1,8 @@
+/*
+ * This file is the entry point of this codebase
+ * - It is responsible to export the documented API
+ * - It should be kept simple (just re-export) to help reader to
+ *   discover codebase progressively
+ */
+
+export { getMessage, getMessageAsync } from "./message.js";

package/template-node-package/src/message.js

@@ -0,0 +1,11 @@
+/*
+ * This file is some boilerplate code meant to be replaced by real code
+ */
+
+export const getMessage = () => {
+  return "Hello dev!";
+};
+
+export const getMessageAsync = async () => {
+  return "Hello dev async!";
+};

package/template-node-package/tests/message.test.mjs

@@ -0,0 +1,21 @@
+/*
+ * This file test the public exports of "jsenv-template-node"
+ * - It illustrates how to test code
+ * - It illustrates how to use top level await to test code
+ */
+
+import { assert } from "@jsenv/assert";
+
+import { getMessage, getMessageAsync } from "jsenv-template-node-package";
+
+{
+  const actual = getMessage();
+  const expect = "Hello dev!";
+  assert({ actual, expect });
+}
+
+{
+  const actual = await getMessageAsync();
+  const expect = "Hello dev async!";
+  assert({ actual, expect });
+}

package/template-web/.eslintignore

@@ -0,0 +1,3 @@
+.jsenv/
+.coverage/
+dist/