@vnejs/monorepo 0.0.2

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@vnejs/monorepo",
+  "version": "0.0.2",
+  "description": "Monorepo tooling for @vnejs",
+  "main": "src/index.js",
+  "bin": {
+    "@vnejs/monorepo": "./src/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "publish:major": "npx @vnejs/monorepo publish major --access public",
+    "publish:minor": "npx @vnejs/monorepo publish minor --access public",
+    "publish:patch": "npx @vnejs/monorepo publish patch --access public"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "~15.0.0",
+    "typescript": "6.0.3"
+  }
+}

package/src/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+
+const packageJson = require("../package.json");
+const publishAction = require("./publish");
+const publishUisAction = require("./publish-uis");
+const publishHelpersAction = require("./publish-helpers");
+const publishConfigsAction = require("./publish-configs");
+
+const program = new Command();
+
+program.name(packageJson.name).description(packageJson.description).version(packageJson.version);
+
+program
+  .command("package")
+  .description("build TypeScript package in current directory")
+  .option("-c, --clean", "remove dist before build", false)
+  .option("--config <path>", "tsconfig path", "tsconfig.json")
+  .action((options) => require("./package")(options));
+
+program
+  .command("publish")
+  .description("Clean-build and publish package in current directory")
+  .argument("[bump]", "major | minor | patch | premajor | preminor | prepatch | prerelease | x.y.z")
+  .option("--access <access>", "npm publish --access", "public")
+  .option("--dry-run", "npm publish --dry-run (version is restored after success)", false)
+  .option("--otp <otp>", "npm publish --otp (only if your npm auth requires it)")
+  .option("--tag <tag>", "npm publish --tag", "latest")
+  .action(publishAction);
+
+program
+  .command("publish-uis")
+  .description("Publish all uis workspace packages in dependency order")
+  .argument("<bump>", "major | minor | patch")
+  .option("--access <access>", "npm publish --access", "public")
+  .option("--dry-run", "npm publish --dry-run", false)
+  .option("--otp <otp>", "npm publish --otp")
+  .option("--tag <tag>", "npm publish --tag", "latest")
+  .action(publishUisAction);
+
+program
+  .command("publish-helpers")
+  .description("Publish all helpers workspace packages in dependency order")
+  .argument("<bump>", "major | minor | patch")
+  .option("--access <access>", "npm publish --access", "public")
+  .option("--dry-run", "npm publish --dry-run", false)
+  .option("--otp <otp>", "npm publish --otp")
+  .option("--tag <tag>", "npm publish --tag", "latest")
+  .action(publishHelpersAction);
+
+program
+  .command("publish-configs")
+  .description("Publish all configs workspace packages in dependency order")
+  .argument("<bump>", "major | minor | patch")
+  .option("--access <access>", "npm publish --access", "public")
+  .option("--dry-run", "npm publish --dry-run", false)
+  .option("--otp <otp>", "npm publish --otp")
+  .option("--tag <tag>", "npm publish --tag", "latest")
+  .action(publishConfigsAction);
+
+program.parse();

package/src/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  package: require("./package"),
+  publish: require("./publish"),
+  publishUis: require("./publish-uis"),
+  publishHelpers: require("./publish-helpers"),
+  publishConfigs: require("./publish-configs"),
+};

package/src/layers/helpers.js

@@ -0,0 +1,26 @@
+const path = require("path");
+const { existsSync } = require("fs");
+const listPackageDirs = require("./list-package-dirs");
+
+module.exports = (root) => {
+  const helpersRoot = path.join(root, "helpers");
+
+  return [
+    {
+      turboFilter: "./helpers/primitives/*",
+      packageDirs: listPackageDirs(path.join(helpersRoot, "primitives")),
+    },
+    {
+      turboFilter: "./helpers/composites/*",
+      packageDirs: listPackageDirs(path.join(helpersRoot, "composites")),
+    },
+    {
+      turboFilter: "./helpers/base",
+      packageDirs: [path.join(helpersRoot, "base")],
+      only: true,
+    },
+  ].map((layer) => ({
+    ...layer,
+    packageDirs: layer.packageDirs.filter((pkgDir) => existsSync(pkgDir)),
+  }));
+};

package/src/layers/list-package-dirs.js

@@ -0,0 +1,9 @@
+const { existsSync, readdirSync } = require("fs");
+const path = require("path");
+
+module.exports = (dir) =>
+  readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist")
+    .map((entry) => path.join(dir, entry.name))
+    .filter((full) => existsSync(path.join(full, "package.json")))
+    .sort();

package/src/layers/uis.js

@@ -0,0 +1,39 @@
+const path = require("path");
+const { existsSync } = require("fs");
+const listPackageDirs = require("./list-package-dirs");
+
+module.exports = (root) => {
+  const uisRoot = path.join(root, "uis");
+
+  return [
+    { turboFilter: "./uis/utils", packageDirs: [path.join(uisRoot, "utils")] },
+    {
+      turboFilter: "./uis/react/hooks/*",
+      packageDirs: listPackageDirs(path.join(uisRoot, "react/hooks")),
+      only: true,
+    },
+    {
+      turboFilter: "./uis/react/primitives/*",
+      packageDirs: listPackageDirs(path.join(uisRoot, "react/primitives")),
+      only: true,
+    },
+    {
+      turboFilter: "./uis/react/composites/*",
+      packageDirs: listPackageDirs(path.join(uisRoot, "react/composites")),
+      only: true,
+    },
+    {
+      turboFilter: "./uis/react/complex/*",
+      packageDirs: listPackageDirs(path.join(uisRoot, "react/complex")),
+      only: true,
+    },
+    {
+      turboFilter: "./uis/react/base",
+      packageDirs: [path.join(uisRoot, "react/base")],
+      only: true,
+    },
+  ].map((layer) => ({
+    ...layer,
+    packageDirs: layer.packageDirs.filter((pkgDir) => existsSync(pkgDir)),
+  }));
+};

package/src/package/index.js

@@ -0,0 +1,21 @@
+const { execSync } = require("child_process");
+const { existsSync } = require("fs");
+const path = require("path");
+
+module.exports = (options = {}) => {
+  const pkgDir = options.cwd || process.cwd();
+  const config = options.config || "tsconfig.json";
+  const configPath = path.join(pkgDir, config);
+
+  if (!existsSync(configPath)) {
+    console.error(`tsconfig not found: ${configPath}`);
+    process.exit(1);
+  }
+
+  if (options.clean) {
+    execSync("rm -rf dist", { cwd: pkgDir, stdio: "inherit" });
+  }
+
+  const tsc = require.resolve("typescript/bin/tsc");
+  execSync(`node "${tsc}" -p "${config}"`, { cwd: pkgDir, stdio: "inherit" });
+};

package/src/publish/index.js

@@ -0,0 +1,47 @@
+const { existsSync } = require("fs");
+const path = require("path");
+
+const { readPackageName, readVersion, run, writeVersion, prepareForPublish } = require("./utils");
+
+module.exports = async (bump, options = {}) => {
+  const pkgDir = process.cwd();
+
+  if (!existsSync(path.join(pkgDir, "package.json"))) {
+    console.error("package.json not found in current directory");
+    process.exit(1);
+  }
+
+  const packageName = readPackageName(pkgDir);
+  const oldVersion = readVersion(pkgDir);
+  const isDryRun = Boolean(options.dryRun);
+  const pkgLabel = packageName ? ` ${packageName}` : "";
+
+  try {
+    if (bump) run(`npm version ${bump} --no-git-tag-version --no-workspaces-update`, pkgDir);
+
+    prepareForPublish(pkgDir);
+
+    const publishArgs = ["npm", "publish"];
+
+    if (options.access) publishArgs.push("--access", options.access);
+    if (isDryRun) publishArgs.push("--dry-run");
+    if (options.otp) publishArgs.push("--otp", options.otp);
+    if (options.tag && options.tag !== "latest") publishArgs.push("--tag", options.tag);
+
+    run(publishArgs.join(" "), pkgDir);
+
+    const publishedVersion = readVersion(pkgDir);
+
+    if (isDryRun) {
+      if (bump) writeVersion(pkgDir, oldVersion);
+      console.log(bump ? `Dry run ok. Version restored: ${oldVersion}` : `Dry run ok. Version unchanged: ${publishedVersion}`);
+      return;
+    }
+
+    console.log(`Пакет ${pkgLabel} успешно опубликован с версией ${publishedVersion}`);
+  } catch {
+    if (bump && readVersion(pkgDir) !== oldVersion) writeVersion(pkgDir, oldVersion);
+    console.error(`Не удалось опубликовать пакет${pkgLabel}. Версия не была изменена (${oldVersion}).`);
+    process.exit(1);
+  }
+};

package/src/publish/utils.js

@@ -0,0 +1,38 @@
+const { execSync } = require("child_process");
+const { existsSync, readFileSync, writeFileSync } = require("fs");
+const path = require("path");
+
+const readPackageJson = (pkgDir) => JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf8"));
+
+const readVersion = (pkgDir) => readPackageJson(pkgDir).version;
+
+const readPackageName = (pkgDir) => readPackageJson(pkgDir).name;
+
+const writeVersion = (pkgDir, version) => {
+  const pkgPath = path.join(pkgDir, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+
+  pkg.version = version;
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+
+  const lockPath = path.join(pkgDir, "package-lock.json");
+  if (!existsSync(lockPath)) return;
+
+  const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+  if (lock.version) lock.version = version;
+  if (lock.packages?.[""]?.version) lock.packages[""].version = version;
+  writeFileSync(lockPath, JSON.stringify(lock, null, 2) + "\n");
+};
+
+const run = (command, pkgDir) => {
+  execSync(command, { cwd: pkgDir, stdio: "inherit" });
+};
+
+const prepareForPublish = (pkgDir) => {
+  const pkg = readPackageJson(pkgDir);
+  if (!pkg.scripts?.build) return;
+
+  run("npx @vnejs/monorepo package --clean", pkgDir);
+};
+
+module.exports = { readPackageName, readVersion, writeVersion, run, prepareForPublish };

package/src/publish-configs/index.js

@@ -0,0 +1,38 @@
+const { execSync } = require("child_process");
+const { existsSync } = require("fs");
+const path = require("path");
+
+module.exports = (bump, options = {}) => {
+  if (!["major", "minor", "patch"].includes(bump)) {
+    console.error("bump must be major, minor, or patch");
+    process.exit(1);
+  }
+
+  const root = process.cwd();
+  const configsRoot = path.join(root, "configs");
+
+  if (!existsSync(configsRoot)) {
+    console.error(`configs directory not found: ${configsRoot}`);
+    process.exit(1);
+  }
+
+  const packageDirs = [
+    path.join(configsRoot, "ts-common"),
+    path.join(configsRoot, "ts-uis"),
+  ].filter((pkgDir) => existsSync(pkgDir));
+
+  const access = options.access || "public";
+  const publishArgs = [`npx @vnejs/monorepo publish ${bump}`, `--access ${access}`];
+  if (options.dryRun) publishArgs.push("--dry-run");
+  if (options.otp) publishArgs.push(`--otp ${options.otp}`);
+  if (options.tag && options.tag !== "latest") publishArgs.push(`--tag ${options.tag}`);
+
+  const command = publishArgs.join(" ");
+
+  for (const pkgDir of packageDirs) {
+    console.log(`\n==> ${path.relative(root, pkgDir)}`);
+    execSync(command, { cwd: pkgDir, stdio: "inherit" });
+  }
+
+  console.log(`\nPublished ${packageDirs.length} configs packages (${bump}).`);
+};

package/src/publish-helpers/index.js

@@ -0,0 +1,36 @@
+const { execSync } = require("child_process");
+const { existsSync } = require("fs");
+const path = require("path");
+const getHelpersLayers = require("../layers/helpers");
+
+module.exports = (bump, options = {}) => {
+  if (!["major", "minor", "patch"].includes(bump)) {
+    console.error("bump must be major, minor, or patch");
+    process.exit(1);
+  }
+
+  const root = process.cwd();
+  const helpersRoot = path.join(root, "helpers");
+
+  if (!existsSync(helpersRoot)) {
+    console.error(`helpers directory not found: ${helpersRoot}`);
+    process.exit(1);
+  }
+
+  const packageDirs = getHelpersLayers(root).flatMap((layer) => layer.packageDirs);
+
+  const access = options.access || "public";
+  const publishArgs = [`npx @vnejs/monorepo publish ${bump}`, `--access ${access}`];
+  if (options.dryRun) publishArgs.push("--dry-run");
+  if (options.otp) publishArgs.push(`--otp ${options.otp}`);
+  if (options.tag && options.tag !== "latest") publishArgs.push(`--tag ${options.tag}`);
+
+  const command = publishArgs.join(" ");
+
+  for (const pkgDir of packageDirs) {
+    console.log(`\n==> ${path.relative(root, pkgDir)}`);
+    execSync(command, { cwd: pkgDir, stdio: "inherit" });
+  }
+
+  console.log(`\nPublished ${packageDirs.length} helpers packages (${bump}).`);
+};

package/src/publish-uis/index.js

@@ -0,0 +1,36 @@
+const { execSync } = require("child_process");
+const { existsSync } = require("fs");
+const path = require("path");
+const getUisLayers = require("../layers/uis");
+
+module.exports = (bump, options = {}) => {
+  if (!["major", "minor", "patch"].includes(bump)) {
+    console.error("bump must be major, minor, or patch");
+    process.exit(1);
+  }
+
+  const root = process.cwd();
+  const uisRoot = path.join(root, "uis");
+
+  if (!existsSync(uisRoot)) {
+    console.error(`uis directory not found: ${uisRoot}`);
+    process.exit(1);
+  }
+
+  const packageDirs = getUisLayers(root).flatMap((layer) => layer.packageDirs);
+
+  const access = options.access || "public";
+  const publishArgs = [`npx @vnejs/monorepo publish ${bump}`, `--access ${access}`];
+  if (options.dryRun) publishArgs.push("--dry-run");
+  if (options.otp) publishArgs.push(`--otp ${options.otp}`);
+  if (options.tag && options.tag !== "latest") publishArgs.push(`--tag ${options.tag}`);
+
+  const command = publishArgs.join(" ");
+
+  for (const pkgDir of packageDirs) {
+    console.log(`\n==> ${path.relative(root, pkgDir)}`);
+    execSync(command, { cwd: pkgDir, stdio: "inherit" });
+  }
+
+  console.log(`\nPublished ${packageDirs.length} uis packages (${bump}).`);
+};