pob 40.3.2 → 40.4.0

package/lib/generators/monorepo/PobMonorepoGenerator.js

@@ -2,13 +2,18 @@ import { execSync } from "node:child_process";
 import fs from "node:fs";
 import { platform } from "node:process";
 import Generator from "yeoman-generator";
+import { isAlouetteApp } from "../../utils/alouette.js";
 import removeLegacyGeneratedDocs from "../../utils/legacyGeneratedDocs.js";
+import { isNodeApp } from "../../utils/nodeApps.js";
 import * as packageUtils from "../../utils/package.js";
 import { packageManagerRun } from "../../utils/packageManagerUtils.js";
 import {
   workspacesRun,
+  workspacesRunExcluding,
+  workspacesRunOnly,
   workspacesRunSequential,
 } from "../../utils/packageManagerWorkspacesUtils.js";
+import { getRollupConfigDependencies } from "../../utils/rollupConfigDependencies.js";
 import {
   detectStorybook,
   detectStorybookReactNative,
@@ -386,6 +391,9 @@ export default class PobMonorepoGenerator extends Generator {
       typescript: this.pobMonorepoConfig.typescript,
       testing: this.pobMonorepoConfig.testing,
       testRunner: this.pobMonorepoConfig.testRunner,
+      tailwind: this.packageConfigs.some((config, index) =>
+        isAlouetteApp(config, this.packages[index]),
+      ),
       packageNames: JSON.stringify(packageNames),
       packageLocations: JSON.stringify(this.packageLocations),
     });
@@ -425,6 +433,17 @@ export default class PobMonorepoGenerator extends Generator {
       isAppProject: this.options.isAppProject,
       packageNames: JSON.stringify(packageNames),
       packagePaths: JSON.stringify(packagePaths),
+      // mirrors the includeScripts option given by the app generator
+      packagePathsWithScriptsIncluded: JSON.stringify(
+        this.packageLocations.filter(
+          (location, index) =>
+            this.pobMonorepoConfig.typescript !== "check-only" &&
+            this.packages[index].pob?.typescript !== "check-only" &&
+            isNodeApp(this.packageConfigs[index]) &&
+            packagePaths.includes(location) &&
+            fs.existsSync(`${location}/scripts`),
+        ),
+      ),
       testRunner: this.pobMonorepoConfig.testRunner,
       onlyLatestLTS: this.options.onlyLatestLTS,
       packageManager: this.options.packageManager,
@@ -432,6 +451,8 @@ export default class PobMonorepoGenerator extends Generator {
 
     this.fs.writeJSON(this.destinationPath("package.json"), pkg);
 
+    if (this.options.check) return;
+
     if (platform !== "win32") {
       execSync(
         `rm -Rf ${["lib-*", "coverage", "generated-docs"].filter(Boolean).join(" ")}`,
@@ -453,6 +474,7 @@ export default class PobMonorepoGenerator extends Generator {
       });
 
       const rollupConfigs = [];
+      const rollupConfigContents = [];
       this.packageLocations.forEach((location) => {
         const rollupPath = `${location}/rollup.config.mjs`;
         const rollupConfig = this.fs.read(this.destinationPath(rollupPath), {
@@ -460,9 +482,21 @@ export default class PobMonorepoGenerator extends Generator {
         });
         if (rollupConfig) {
           rollupConfigs.push(rollupPath);
+          rollupConfigContents.push(rollupConfig);
         }
       });
 
+      // built before the root rollup config loads them, and kept out of
+      // clean:build which runs in between
+      const rollupConfigDependencies = getRollupConfigDependencies(
+        this.packages,
+        rollupConfigContents,
+      );
+      const buildRollupConfigDependencies =
+        rollupConfigDependencies.length > 0
+          ? `${workspacesRunOnly(this.options.packageManager, "build", ...rollupConfigDependencies)} && `
+          : "";
+
       if (rollupConfigs.length > 0) {
         await copyAndFormatTpl(
           this.fs,
@@ -476,12 +510,16 @@ export default class PobMonorepoGenerator extends Generator {
         this.fs.delete("rollup.config.mjs");
       }
       packageUtils.addOrRemoveScripts(pkg, rollupConfigs.length > 0, {
-        "clean:build": workspacesRun(
-          this.options.packageManager,
-          "clean:build",
-        ),
-        build: `${packageManagerRun(this.options.packageManager, "clean:build")} && rollup --config rollup.config.mjs`,
-        watch: `${packageManagerRun(this.options.packageManager, "clean:build")} && rollup --config rollup.config.mjs --watch`,
+        "clean:build":
+          rollupConfigDependencies.length > 0
+            ? workspacesRunExcluding(
+                this.options.packageManager,
+                "clean:build",
+                ...rollupConfigDependencies,
+              )
+            : workspacesRun(this.options.packageManager, "clean:build"),
+        build: `${buildRollupConfigDependencies}${packageManagerRun(this.options.packageManager, "clean:build")} && rollup --config rollup.config.mjs`,
+        watch: `${buildRollupConfigDependencies}${packageManagerRun(this.options.packageManager, "clean:build")} && rollup --config rollup.config.mjs --watch`,
       });
 
       const hasExpoApp = this.packageConfigs.some(

package/lib/generators/monorepo/typescript/MonorepoTypescriptGenerator.js

@@ -57,6 +57,14 @@ export default class MonorepoTypescriptGenerator extends Generator {
       required: true,
     });
 
+    this.option("packagePathsWithScriptsIncluded", {
+      type: String,
+      required: false,
+      default: "[]",
+      description:
+        "packages whose tsconfig.json includes their scripts (node apps)",
+    });
+
     this.option("testRunner", {
       type: String,
       required: false,
@@ -85,7 +93,8 @@ export default class MonorepoTypescriptGenerator extends Generator {
   // emitting tsconfig, so it needs a dedicated noEmit project for type-aware
   // linting and tsc -b: root config files (e.g. vitest.config.ts), a root
   // scripts/ dir, and each package's scripts/ dir (matched via the workspace
-  // globs so all packages are covered)
+  // globs so all packages are covered, except node apps which include them in
+  // their own tsconfig.json)
   #hasTools() {
     return (
       hasRootConfigFiles(this.destinationPath()) ||
@@ -199,6 +208,9 @@ export default class MonorepoTypescriptGenerator extends Generator {
           {
             nodeVersion: latestLTS,
             workspaceGlobs,
+            packagePathsWithScriptsIncluded: JSON.parse(
+              this.options.packagePathsWithScriptsIncluded,
+            ),
           },
         );
       } else {

package/lib/generators/monorepo/typescript/templates/tsconfig.tools.json.ejs

@@ -21,6 +21,13 @@
     "<%= workspaceGlob %>/e2e/**/*.cts"<%= index === workspaceGlobs.length - 1 ? '' : ',' %>
 <% }) -%>
   ],
+<% if (packagePathsWithScriptsIncluded.length > 0) { -%>
+  "exclude": [
+<% packagePathsWithScriptsIncluded.forEach((packagePath, index) => { -%>
+    "<%= packagePath %>/scripts/**"<%= index === packagePathsWithScriptsIncluded.length - 1 ? '' : ',' %>
+<% }) -%>
+  ],
+<% } -%>
   "compilerOptions": {
     "noEmit": true,
     "tsBuildInfoFile": "node_modules/.cache/tsc/tsbuildinfo-tools",

package/lib/generators/monorepo/workspaces/MonorepoWorkspacesGenerator.js

@@ -199,21 +199,26 @@ export default class MonorepoWorkspacesGenerator extends Generator {
         return;
       }
       console.log(`=> update ${packagePath}`);
-      spawnSync(
+      const { status } = spawnSync(
         process.argv[0],
         [
           process.argv[1],
           "update",
           "from-pob",
-          this.options.force ? "--force" : undefined,
+          this.options.check && "--check",
+          !this.options.check && this.options.force && "--force",
         ].filter(Boolean),
         {
           cwd: packagePath,
           stdio: "inherit",
         },
       );
+      // with --check, a package exits with 1 when a file would change
+      if (this.options.check && status !== 0) process.exitCode = 1;
     });
 
+    if (this.options.check) return;
+
     switch (this.options.packageManager) {
       case "npm":
         this.spawnSync("npm", ["install"]);

package/lib/generators/pob/PobBaseGenerator.js

@@ -45,7 +45,9 @@ export default class PobBaseGenerator extends Generator {
 
   async initializing() {
     // format package.json to ensure diff is correct
-    await ensureJsonFileFormatted(this.destinationPath("package.json"));
+    if (!this.options.check) {
+      await ensureJsonFileFormatted(this.destinationPath("package.json"));
+    }
 
     if (this.options.monorepo) {
       this.isMonorepo = true;
@@ -296,7 +298,7 @@ export default class PobBaseGenerator extends Generator {
   }
 
   install() {
-    if (this.options.fromPob) return;
+    if (this.options.fromPob || this.options.check) return;
 
     switch (this.#getPackageManager()) {
       case "npm":

package/lib/pob.js

@@ -51,12 +51,42 @@ import { getNewPackagePath } from "./utils/workspaceUtils.js";
 
 const printUsage = () => {
   console.error("Usage: pob [monorepo] [lib|app|init]");
-  console.error("       pob [monorepo] update [--force]");
+  console.error("       pob [monorepo] update [--force|--check]");
   console.error(
     "       pob add <packageName> [--app <appType> [--testing] [--e2e]]",
   );
 };
 
+const printHelp = () => {
+  console.log(`Usage: pob [monorepo] [lib|app|init]
+       pob [monorepo] update [from-pob] [--force|--check]
+       pob add <packageName> [--app <appType> [--testing] [--e2e]]
+       pob migrate-to-monorepo
+
+Commands:
+  lib                    Generate a library
+  app                    Generate an app
+  init                   Initialize pob config, prompting for project type
+  update                 Regenerate files from the existing .yo-rc.json, without prompts
+  update from-pob        Same as update, without running install or build
+  add <packageName>      Add a new package to the monorepo workspaces
+  migrate-to-monorepo    Move the current project into packages/<name> and create a monorepo root
+
+  monorepo               Prefix to force monorepo mode (auto-detected from workspaces or lerna.json)
+
+Options:
+  --force                Overwrite every file without asking
+  --check                With update (implied when no command is given): print
+                         the diffs without writing anything or running install,
+                         exit with code 1 when a file would change
+  --app <appType>        With add: generate an app package without prompts
+                         (alp, vite, vite-with-server, next.js, node, node-library,
+                         untranspiled-library, alp-node, expo, other)
+  --testing              With add --app: enable testing
+  --e2e                  With add --app: enable e2e testing
+  -h, --help             Show this help`);
+};
+
 const readJson = (filepath) => {
   try {
     return JSON.parse(readFileSync(filepath, "utf8"));
@@ -69,14 +99,39 @@ const readJson = (filepath) => {
 //   console.log(pkg.version);
 // };
 
-const argv = minimist(process.argv.slice(2));
+const argv = minimist(process.argv.slice(2), { alias: { h: "help" } });
+
+if (argv.help || argv._[0] === "help") {
+  printHelp();
+  process.exit(0);
+}
 
 if (argv.version) {
   // printVersion();
   process.exit(0);
 }
 
-const env = yeoman.createEnv();
+const check = !!argv.check;
+
+// dryRun: the conflicter prints the diffs and skips every write.
+// sharedOptions.check: generators skip their side effects outside mem-fs.
+const env = yeoman.createEnv(
+  check
+    ? { dryRun: true, skipInstall: true, sharedOptions: { check: true } }
+    : {},
+);
+
+// the conflicter clears its file statuses after each file: collect them as logged
+const changedFiles = [];
+if (check) {
+  for (const status of ["create", "conflict"]) {
+    const log = env.adapter.log[status];
+    env.adapter.log[status] = (filePath, ...args) => {
+      changedFiles.push(filePath);
+      return log.call(env.adapter.log, filePath, ...args);
+    };
+  }
+}
 
 env.on("error", (err) => {
   console.error(err.stack || err.message || err);
@@ -266,7 +321,13 @@ env.registerStub(
 const projectPkg = readJson(path.resolve("./package.json"));
 const monorepoArg = argv._[0] === "lerna" || argv._[0] === "monorepo";
 let monorepo = monorepoArg || !!(projectPkg && projectPkg.workspaces);
-const action = monorepoArg ? argv._[1] : argv._[0];
+const action = (monorepoArg ? argv._[1] : argv._[0]) ?? (check && "update");
+
+if (check && action !== "update") {
+  console.error("--check can only be used with update");
+  printUsage();
+  process.exit(1);
+}
 
 if (action === "add") {
   if (!projectPkg.workspaces) {
@@ -417,7 +478,8 @@ const options = {
   updateOnly,
   monorepo,
   fromPob,
-  force: argv.force,
+  // force bypasses the conflicter diff
+  force: check ? false : argv.force,
 };
 
 try {
@@ -429,6 +491,14 @@ try {
   }
 }
 
+if (check) {
+  if (changedFiles.length > 0) {
+    console.error(`pob --check: ${changedFiles.length} file(s) would change:`);
+    for (const file of changedFiles) console.error(`  ${file}`);
+    process.exitCode = 1;
+  }
+}
+
 // generator.on('error', (err) => {
 //   console.error(err.stack || err.message || err);
 //   process.exit(1);

package/lib/utils/alouette.js

@@ -0,0 +1,18 @@
+// alouette styles components with tailwind (nativewind) and tailwind-variants
+
+/** @param {Record<string, any>} pkg */
+export const detectAlouette = (pkg) =>
+  [pkg.dependencies, pkg.devDependencies].some(
+    (dependencies) => dependencies?.alouette !== undefined,
+  );
+
+/**
+ * Fallback on the dependencies for an app config missing the option.
+ *
+ * @param {Record<string, any> | undefined} pobConfig
+ * @param {Record<string, any>} pkg
+ */
+export const isAlouetteApp = (pobConfig, pkg) =>
+  pobConfig?.project?.type === "app" &&
+  pobConfig.app?.type === "expo" &&
+  (pobConfig.app.alouette ?? detectAlouette(pkg));

package/lib/utils/appTsconfigTarget.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { buildDependentsMaps, discoverWorkspaces } from "./workspaceUtils.js";
+
+export const appsWithBrowser = ["alp", "next.js", "vite", "vite-with-server"];
+
+const expoTarget = "@pob/root/tsconfigs/targets/expo.json";
+
+// based on the app type from the pob config rather than on the package.json
+// dependencies, which can change without pob being run again
+export const getAppTsconfigTarget = ({ appType, dom, withBun }) => {
+  if (appType === "expo") return expoTarget;
+  if (dom) {
+    return appType === "vite" || appType === "vite-with-server"
+      ? "@pob/root/tsconfigs/targets/vite.json"
+      : "@pob/root/tsconfigs/targets/webpack.json";
+  }
+  if (withBun) return "@pob/root/tsconfigs/targets/bun.json";
+  return undefined;
+};
+
+const readPobConfig = (location) => {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(location, ".yo-rc.json"))).pob;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Target of the apps directly depending on the package, for packages compiled
+ * by the bundler of these apps (untranspiled libraries). Expo wins as the
+ * widest target, otherwise the apps must agree on a single target.
+ */
+export const getConsumerAppsTsconfigTarget = async ({
+  rootPath,
+  packageName,
+  withBun,
+}) => {
+  const workspaces = await discoverWorkspaces(rootPath);
+  const workspace = workspaces.find((w) => w.name === packageName);
+  if (!workspace) return undefined;
+
+  const dependents = buildDependentsMaps(workspaces).get(workspace) || [];
+  const targets = new Set();
+  for (const [dependent] of dependents) {
+    const pobConfig = readPobConfig(path.join(rootPath, dependent.location));
+    if (pobConfig?.project?.type !== "app") continue;
+    const appType = pobConfig.app?.type;
+    const target = getAppTsconfigTarget({
+      appType,
+      dom: appsWithBrowser.includes(appType),
+      withBun,
+    });
+    if (target) targets.add(target);
+  }
+
+  if (targets.has(expoTarget)) return expoTarget;
+  return targets.size === 1 ? [...targets][0] : undefined;
+};

package/lib/utils/appTsconfigTarget.test.js

@@ -0,0 +1,169 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  getAppTsconfigTarget,
+  getConsumerAppsTsconfigTarget,
+} from "./appTsconfigTarget.js";
+
+const targets = {
+  expo: "@pob/root/tsconfigs/targets/expo.json",
+  vite: "@pob/root/tsconfigs/targets/vite.json",
+  webpack: "@pob/root/tsconfigs/targets/webpack.json",
+  bun: "@pob/root/tsconfigs/targets/bun.json",
+};
+
+describe("getAppTsconfigTarget", () => {
+  it("returns expo for expo apps", () => {
+    expect(getAppTsconfigTarget({ appType: "expo", dom: false })).toBe(
+      targets.expo,
+    );
+  });
+
+  it("returns vite for vite apps", () => {
+    expect(getAppTsconfigTarget({ appType: "vite", dom: true })).toBe(
+      targets.vite,
+    );
+    expect(
+      getAppTsconfigTarget({ appType: "vite-with-server", dom: true }),
+    ).toBe(targets.vite);
+  });
+
+  it("returns webpack for other browser apps and dom libraries", () => {
+    expect(getAppTsconfigTarget({ appType: "alp", dom: true })).toBe(
+      targets.webpack,
+    );
+    expect(getAppTsconfigTarget({ appType: undefined, dom: true })).toBe(
+      targets.webpack,
+    );
+  });
+
+  it("returns bun without dom with bun", () => {
+    expect(
+      getAppTsconfigTarget({ appType: "node", dom: false, withBun: true }),
+    ).toBe(targets.bun);
+  });
+
+  it("returns undefined for node apps", () => {
+    expect(getAppTsconfigTarget({ appType: "node", dom: false })).toBe(
+      undefined,
+    );
+  });
+});
+
+async function writeWorkspace(rootPath, location, pkg, pobConfig) {
+  const dir = path.join(rootPath, location);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(path.join(dir, "package.json"), JSON.stringify(pkg));
+  if (pobConfig) {
+    await fs.writeFile(
+      path.join(dir, ".yo-rc.json"),
+      JSON.stringify({ pob: pobConfig }),
+    );
+  }
+}
+
+const app = (type) => ({ project: { type: "app" }, app: { type } });
+
+/**
+ * Monorepo with an untranspiled library "@ex/lib" and the given consumers,
+ * each one an [appType, pobConfig] pair depending on the library.
+ */
+async function prepareMonorepo(consumers) {
+  const rootPath = await fs.mkdtemp(path.join(os.tmpdir(), "pob-"));
+  await writeWorkspace(rootPath, ".", {
+    name: "root",
+    workspaces: ["packages/*"],
+  });
+  await writeWorkspace(
+    rootPath,
+    "packages/lib",
+    { name: "@ex/lib" },
+    app("untranspiled-library"),
+  );
+  for (const [name, pobConfig] of consumers) {
+    await writeWorkspace(
+      rootPath,
+      `packages/${name}`,
+      { name: `@ex/${name}`, dependencies: { "@ex/lib": "workspace:*" } },
+      pobConfig,
+    );
+  }
+  return rootPath;
+}
+
+const getLibTarget = async (consumers, { withBun = false } = {}) =>
+  getConsumerAppsTsconfigTarget({
+    rootPath: await prepareMonorepo(consumers),
+    packageName: "@ex/lib",
+    withBun,
+  });
+
+describe("getConsumerAppsTsconfigTarget", () => {
+  it("uses the target of a consumer expo app", async () => {
+    expect(await getLibTarget([["mobile", app("expo")]])).toBe(targets.expo);
+  });
+
+  it("prefers expo when consumer apps disagree", async () => {
+    expect(
+      await getLibTarget([
+        ["mobile", app("expo")],
+        ["web", app("vite")],
+        ["api", app("node")],
+      ]),
+    ).toBe(targets.expo);
+  });
+
+  it("uses the target shared by all consumer apps", async () => {
+    expect(
+      await getLibTarget([
+        ["web", app("vite")],
+        ["api", app("node")],
+      ]),
+    ).toBe(targets.vite);
+  });
+
+  it("returns undefined when consumer apps disagree without expo", async () => {
+    expect(
+      await getLibTarget([
+        ["web", app("vite")],
+        ["legacy", app("alp")],
+      ]),
+    ).toBe(undefined);
+  });
+
+  it("returns undefined without consumer apps with a target", async () => {
+    expect(await getLibTarget([])).toBe(undefined);
+    expect(await getLibTarget([["api", app("node")]])).toBe(undefined);
+    expect(
+      await getLibTarget([["other-lib", { project: { type: "lib" } }]]),
+    ).toBe(undefined);
+    expect(await getLibTarget([["no-config", undefined]])).toBe(undefined);
+  });
+
+  it("uses bun for node consumer apps with bun", async () => {
+    expect(await getLibTarget([["api", app("node")]], { withBun: true })).toBe(
+      targets.bun,
+    );
+  });
+
+  it("ignores apps depending on the library through another library", async () => {
+    const rootPath = await prepareMonorepo([
+      ["other-lib", app("untranspiled-library")],
+    ]);
+    await writeWorkspace(
+      rootPath,
+      "packages/mobile",
+      { name: "@ex/mobile", dependencies: { "@ex/other-lib": "workspace:*" } },
+      app("expo"),
+    );
+    expect(
+      await getConsumerAppsTsconfigTarget({
+        rootPath,
+        packageName: "@ex/lib",
+        withBun: false,
+      }),
+    ).toBe(undefined);
+  });
+});

package/lib/utils/nodeApps.js

@@ -0,0 +1,8 @@
+// node backend apps: their scripts run in the same environment as their
+// sources, so the package tsconfig.json type-checks them too instead of a
+// separate tsconfig.tools.json
+export const nodeAppTypes = ["node", "node-library", "alp-node"];
+
+export const isNodeApp = (pobConfig) =>
+  pobConfig?.project?.type === "app" &&
+  nodeAppTypes.includes(pobConfig.app?.type);

package/lib/utils/packageManagerWorkspacesUtils.js

@@ -58,6 +58,42 @@ export const workspacesRunSequential = (packageManager, script) => {
   }
 };
 
+/**
+ * Run a script in the given workspaces only, in topological dependency order.
+ * Use to build packages other builds depend on first.
+ */
+export const workspacesRunOnly = (packageManager, script, ...packageNames) => {
+  switch (packageManager) {
+    case undefined:
+    case "yarn": {
+      const includeArgs = packageNames
+        .map((name) => `--include "${name}"`)
+        .join(" ");
+      return `yarn workspaces foreach --topological-dev ${includeArgs} -Av run ${script}`;
+    }
+    case "pnpm": {
+      const filterArgs = packageNames
+        .map((name) => `--filter "${name}"`)
+        .join(" ");
+      return `pnpm ${filterArgs} run ${script}`;
+    }
+    case "npm": {
+      const workspaceArgs = packageNames
+        .map((name) => `--workspace "${name}"`)
+        .join(" ");
+      return `npm run ${script} ${workspaceArgs}`;
+    }
+    case "bun": {
+      const filterArgs = packageNames
+        .map((name) => `--filter '${name}'`)
+        .join(" ");
+      return `bun ${filterArgs} run ${script}`;
+    }
+    default:
+      throw new Error(`Unsupported package manager: ${packageManager}`);
+  }
+};
+
 /**
  * Run a script in all workspaces in parallel, excluding packages matching the given patterns.
  * Use for watch commands where example/demo packages should be skipped.

package/lib/utils/rollupConfigDependencies.js

@@ -0,0 +1,17 @@
+const escapeRegExp = (value) => value.replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+
+/**
+ * Names of the workspace packages imported by a rollup config (e.g. a rollup
+ * plugin): the root rollup config loads them from their build output, so
+ * they must be built before it runs. Only packages with a build script.
+ */
+export const getRollupConfigDependencies = (packages, rollupConfigContents) =>
+  packages
+    .filter((pkg) => {
+      if (!pkg.scripts?.build) return false;
+      const importRegex = new RegExp(
+        `from\\s+["']${escapeRegExp(pkg.name)}(?:/[^"']*)?["']`,
+      );
+      return rollupConfigContents.some((content) => importRegex.test(content));
+    })
+    .map((pkg) => pkg.name);