auklet 0.0.19 → 0.0.21

package/dist/publish/targetResolver.js

@@ -0,0 +1,195 @@
+import path from 'node:path';
+import { createScopedAukletLogger } from '#auklet/logger';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
+import { getPublishConfig, readPackageJson, requirePackageName, requirePackageVersion, } from '#auklet/publish/api/packageJsonApi';
+import { readPnpmWorkspacePackages } from '#auklet/publish/api/pnpmApi';
+import { resolvePublishVersion, validateVersionConsistency, } from '#auklet/publish/version';
+export async function resolvePublishPlan(options, logger = createScopedAukletLogger('publish')) {
+    if (options.filters.length) {
+        return resolveMonorepoPublishPlan(options, logger);
+    }
+    return resolveCurrentPackagePublishPlan(options);
+}
+export async function resolveOwnerPackageNames(options) {
+    if (options.filters.length && options.packages.length) {
+        throw new Error('[auklet:publish] owner command cannot use --filter and --package together.');
+    }
+    if (options.filters.length) {
+        const root = requireWorkspaceRoot(options.cwd);
+        const packages = await readPnpmWorkspacePackages(root);
+        return filterWorkspacePackages(packages, options.filters)
+            .filter((item) => !item.private)
+            .map((item) => item.name);
+    }
+    if (options.packages.length)
+        return [...new Set(options.packages)];
+    const packageJson = readPackageJson(options.cwd);
+    if (packageJson.private) {
+        throw new Error('[auklet:publish] current package is private.');
+    }
+    return [requirePackageName(options.cwd, packageJson)];
+}
+const resolveCurrentPackagePublishPlan = async (options) => {
+    const packageRoot = path.resolve(options.cwd);
+    const packageJson = readPackageJson(packageRoot);
+    const version = requirePackageVersion(packageRoot, packageJson);
+    const workspaceRoot = findWorkspaceRoot(packageRoot);
+    if (workspaceRoot === packageRoot && packageJson.private) {
+        throw new Error('[auklet:publish] current directory is a private monorepo root. Use --filter to select workspace packages.');
+    }
+    const publishVersion = await resolvePublishVersion(version, options.version, packageRoot);
+    const target = createPublishTarget({
+        packageRoot,
+        packageJson,
+        publishVersion,
+        workspaceMode: 'single',
+    });
+    validatePublishTargets([target]);
+    return {
+        root: packageRoot,
+        version: publishVersion,
+        dryRun: options.dryRun,
+        targets: [target],
+        config: getPublishConfig(packageJson),
+        workspaceMode: 'single',
+    };
+};
+const resolveMonorepoPublishPlan = async (options, logger) => {
+    const root = requireWorkspaceRoot(options.cwd);
+    const rootPackageJson = readPackageJson(root);
+    const rootVersion = requirePackageVersion(root, rootPackageJson);
+    const workspacePackages = await readPnpmWorkspacePackages(root);
+    const selectedPackages = filterWorkspacePackages(workspacePackages, options.filters);
+    const publishVersion = await resolvePublishVersion(rootVersion, options.version, root);
+    const targets = selectedPackages
+        .filter((item) => {
+        if (!item.private)
+            return true;
+        if (isExactlyMatchedByFilter(item.name, options.filters)) {
+            logger.warnOnce('package ', logger.package(item.name), ' is private, skipping.');
+        }
+        return false;
+    })
+        .map((item) => {
+        const packageJson = readPackageJson(item.path);
+        return createPublishTarget({
+            packageRoot: item.path,
+            packageJson,
+            publishVersion,
+            workspaceMode: 'monorepo',
+        });
+    });
+    validatePublishTargets(targets);
+    validateWorkspaceInternalDependencies(targets);
+    if (!options.version) {
+        validateVersionConsistency(rootVersion, targets);
+    }
+    return {
+        root,
+        version: publishVersion,
+        dryRun: options.dryRun,
+        targets: sortTargetsByWorkspaceDependencies(targets),
+        config: getPublishConfig(rootPackageJson),
+        workspaceMode: 'monorepo',
+    };
+};
+const requireWorkspaceRoot = (cwd) => {
+    const root = findWorkspaceRoot(cwd);
+    if (!root) {
+        throw new Error('[auklet:publish] --filter requires a pnpm workspace root.');
+    }
+    return root;
+};
+const filterWorkspacePackages = (packages, filters) => {
+    const matched = packages.filter((item) => filters.some((filter) => matchesFilter(item.name, filter)));
+    if (!matched.length) {
+        throw new Error(`[auklet:publish] no workspace package matched filter: ${filters.join(', ')}`);
+    }
+    return matched;
+};
+const matchesFilter = (packageName, filter) => {
+    if (filter.endsWith('/*')) {
+        const scope = filter.slice(0, -2);
+        return packageName.startsWith(`${scope}/`);
+    }
+    return packageName === filter;
+};
+const isExactlyMatchedByFilter = (packageName, filters) => {
+    return filters.some((filter) => filter === packageName);
+};
+const createPublishTarget = (options) => {
+    const packageName = requirePackageName(options.packageRoot, options.packageJson);
+    const version = requirePackageVersion(options.packageRoot, options.packageJson);
+    return {
+        packageRoot: options.packageRoot,
+        packageName,
+        version,
+        publishVersion: options.publishVersion,
+        private: options.packageJson.private === true,
+        kind: 'package',
+        workspaceMode: options.workspaceMode,
+        packageJson: options.packageJson,
+    };
+};
+const validatePublishTargets = (targets) => {
+    const publishableTargets = targets.filter((target) => !target.private);
+    if (!publishableTargets.length) {
+        throw new Error('[auklet:publish] no publishable package found.');
+    }
+};
+const sortTargetsByWorkspaceDependencies = (targets) => {
+    const targetNames = new Set(targets.map((target) => target.packageName));
+    const visited = new Set();
+    const visiting = new Set();
+    const sorted = [];
+    const targetMap = new Map(targets.map((target) => [target.packageName, target]));
+    const visit = (target) => {
+        if (visited.has(target.packageName))
+            return;
+        if (visiting.has(target.packageName)) {
+            throw new Error(`[auklet:publish] circular workspace dependency detected at ${target.packageName}.`);
+        }
+        visiting.add(target.packageName);
+        for (const dependency of getWorkspaceDependencies(target.packageJson)) {
+            if (!targetNames.has(dependency))
+                continue;
+            const dependencyTarget = targetMap.get(dependency);
+            if (dependencyTarget)
+                visit(dependencyTarget);
+        }
+        visiting.delete(target.packageName);
+        visited.add(target.packageName);
+        sorted.push(target);
+    };
+    for (const target of targets) {
+        visit(target);
+    }
+    return sorted;
+};
+const getWorkspaceDependencies = (packageJson) => {
+    return Object.entries({
+        ...packageJson.dependencies,
+        ...packageJson.optionalDependencies,
+    })
+        .filter(([, version]) => version === 'workspace:*')
+        .map(([packageName]) => packageName);
+};
+const validateWorkspaceInternalDependencies = (targets) => {
+    const targetNames = new Set(targets.map((target) => target.packageName));
+    for (const target of targets) {
+        for (const dependencyGroup of workspaceDependencyGroups) {
+            for (const [packageName, version] of Object.entries(target.packageJson[dependencyGroup] ?? {})) {
+                if (!targetNames.has(packageName))
+                    continue;
+                if (version === 'workspace:*')
+                    continue;
+                throw new Error(`[auklet:publish] package ${target.packageName} ${dependencyGroup} ${packageName} must use workspace:* before publishing.`);
+            }
+        }
+    }
+};
+const workspaceDependencyGroups = [
+    'dependencies',
+    'optionalDependencies',
+    'peerDependencies',
+];

package/dist/publish/types.d.ts

@@ -0,0 +1,70 @@
+export type PackageJson = {
+    name?: string;
+    version?: string;
+    private?: boolean;
+    scripts?: Record<string, string>;
+    files?: Array<string>;
+    publishConfig?: {
+        access?: string;
+        [key: string]: unknown;
+    };
+    auklet?: {
+        publish?: PublishPackageConfig;
+        [key: string]: unknown;
+    };
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    [key: string]: unknown;
+};
+export type PublishPackageConfig = {
+    beforeBuild?: PublishHookConfig;
+    afterBuild?: PublishHookConfig;
+    beforePublish?: PublishHookConfig;
+    afterPublish?: PublishHookConfig;
+};
+export type PublishHookConfig = string | Array<string>;
+export type PublishTarget = {
+    packageRoot: string;
+    packageName: string;
+    version: string;
+    publishVersion: string;
+    private: boolean;
+    kind: 'package' | 'lib';
+    workspaceMode: 'single' | 'monorepo';
+    packageJson: PackageJson;
+};
+export type WorkspacePackage = {
+    name: string;
+    path: string;
+    version: string;
+    private?: boolean;
+};
+export type PublishOptions = {
+    cwd: string;
+    filters: Array<string>;
+    version?: string;
+    dryRun: boolean;
+    format: boolean;
+    otp?: string;
+    ignoreScripts: boolean;
+    allowDirty: boolean;
+};
+export type OwnerOptions = {
+    cwd: string;
+    users: Array<string>;
+    filters: Array<string>;
+    packages: Array<string>;
+    otp?: string;
+};
+export type PublishPlan = {
+    root: string;
+    version: string;
+    dryRun: boolean;
+    targets: Array<PublishTarget>;
+    config: PublishPackageConfig;
+    workspaceMode: 'single' | 'monorepo';
+};
+export type HookStatus = 'beforeBuild' | 'afterBuild' | 'beforePublish' | 'afterPublish';
+export type HookResult = 'success' | 'failure';

package/dist/publish/version.d.ts

@@ -0,0 +1,5 @@
+export declare function resolvePublishVersion(currentVersion: string, versionSpec: string | undefined, cwd: string): Promise<string>;
+export declare function validateVersionConsistency(expectedVersion: string, versions: Array<{
+    packageName: string;
+    version: string;
+}>): void;

package/dist/publish/version.js

@@ -0,0 +1,55 @@
+import semver from 'semver';
+import { getGitShortHash } from '#auklet/publish/api/gitApi';
+const prereleaseKinds = new Set(['alpha', 'beta']);
+const releaseIncrements = new Set(['patch', 'minor', 'major']);
+export async function resolvePublishVersion(currentVersion, versionSpec, cwd) {
+    if (!versionSpec) {
+        if (!semver.valid(currentVersion)) {
+            throw new Error(`[auklet:publish] invalid package version: ${currentVersion}`);
+        }
+        return currentVersion;
+    }
+    if (releaseIncrements.has(versionSpec)) {
+        const parsed = semver.parse(currentVersion);
+        if (!parsed) {
+            throw new Error(`[auklet:publish] invalid package version: ${currentVersion}`);
+        }
+        const baseVersion = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+        const next = semver.inc(baseVersion, versionSpec);
+        if (!next) {
+            throw new Error(`[auklet:publish] failed to bump version ${currentVersion} with ${versionSpec}.`);
+        }
+        return next;
+    }
+    if (prereleaseKinds.has(versionSpec)) {
+        const parsed = semver.parse(currentVersion);
+        if (!parsed) {
+            throw new Error(`[auklet:publish] invalid package version: ${currentVersion}`);
+        }
+        const suffix = (await getGitShortHash(cwd)) ?? createTimestamp();
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}-${versionSpec}.${suffix}`;
+    }
+    const explicit = semver.valid(versionSpec);
+    if (explicit)
+        return explicit;
+    throw new Error(`[auklet:publish] unsupported --version value: ${versionSpec}`);
+}
+export function validateVersionConsistency(expectedVersion, versions) {
+    for (const item of versions) {
+        if (item.version !== expectedVersion) {
+            throw new Error(`[auklet:publish] package ${item.packageName} version ${item.version} does not match shared version ${expectedVersion}.`);
+        }
+    }
+}
+const createTimestamp = () => {
+    const date = new Date();
+    const pad = (value) => value.toString().padStart(2, '0');
+    return [
+        date.getFullYear(),
+        pad(date.getMonth() + 1),
+        pad(date.getDate()),
+        pad(date.getHours()),
+        pad(date.getMinutes()),
+        pad(date.getSeconds()),
+    ].join('');
+};

package/dist/types.d.ts

@@ -53,11 +53,6 @@ export interface AukletConfig {
     styles?: StyleOptions;
     build?: PackageBuildOptions;
 }
-export type AukletLogger = {
-    log?: (...args: Array<unknown>) => void;
-    info?: (...args: Array<unknown>) => void;
-    error?: (...args: Array<unknown>) => void;
-};
 export type LoadAukletConfigOptions = {
     configFile?: string;
     cacheBust?: boolean;
@@ -65,7 +60,6 @@ export type LoadAukletConfigOptions = {
 export interface ModuleStyleBuildContext {
     packageRoot?: string;
     aukletConfig?: AukletConfig;
-    logger?: AukletLogger;
     source?: string;
     output?: string;
 }
@@ -76,7 +70,14 @@ export interface ResolvedModuleStyleBuildContext {
 }
 export type ModuleStyleBuildOptions = {
     aukletConfig?: AukletConfig;
-    logger?: AukletLogger;
+};
+export type ModuleStyleBuildResult = {
+    packageRoot: string;
+    styleFiles: Array<string>;
+    outputs: Array<{
+        file: string;
+        size: number;
+    }>;
 };
 export interface ModuleStyleBuildOutputConfig {
     outputFormats: Array<string>;

package/dist/workspace/packages.d.ts

@@ -0,0 +1,9 @@
+import { type Options } from 'execa';
+export type WorkspacePackageInfo = {
+    name: string;
+    path: string;
+    version?: string;
+    private?: boolean;
+};
+export declare function readPnpmWorkspacePackageInfo(root: string, options?: Options): Promise<WorkspacePackageInfo[]>;
+export declare function readPnpmWorkspacePackageInfoSync(root: string): WorkspacePackageInfo[];

package/dist/workspace/packages.js

@@ -0,0 +1,62 @@
+import { execa, execaSync } from 'execa';
+import { isArray, isPlainObject, isString } from 'aidly';
+const pnpmWorkspaceListArgs = ['list', '-r', '--depth', '-1', '--json'];
+const parsePnpmWorkspacePackages = (value) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error('[auklet:workspace] failed to parse workspace packages.', {
+            cause: error,
+        });
+    }
+    if (!isArray(parsed)) {
+        throwInvalidWorkspacePackages();
+    }
+    return parsed.map((item) => {
+        if (!isWorkspacePackageInfo(item))
+            throwInvalidWorkspacePackages();
+        return item;
+    });
+};
+export async function readPnpmWorkspacePackageInfo(root, options = {}) {
+    const result = await execa('pnpm', pnpmWorkspaceListArgs, {
+        cwd: root,
+        reject: false,
+        ...options,
+    });
+    if (result.failed) {
+        throw new Error('[auklet:workspace] failed to read workspace packages.', {
+            cause: result.stderr || result.stdout,
+        });
+    }
+    return parsePnpmWorkspacePackages(String(result.stdout ?? ''));
+}
+export function readPnpmWorkspacePackageInfoSync(root) {
+    const result = execaSync('pnpm', pnpmWorkspaceListArgs, {
+        cwd: root,
+        reject: false,
+    });
+    if (result.failed) {
+        throw new Error('[auklet:workspace] failed to read workspace packages.', {
+            cause: result.stderr || result.stdout,
+        });
+    }
+    return parsePnpmWorkspacePackages(String(result.stdout ?? ''));
+}
+const isWorkspacePackageInfo = (value) => {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return (isString(value.name) &&
+        value.name.length > 0 &&
+        isString(value.path) &&
+        value.path.length > 0 &&
+        (value.version === undefined || isString(value.version)) &&
+        (value.private === undefined || typeof value.private === 'boolean'));
+};
+function throwInvalidWorkspacePackages() {
+    throw new Error('[auklet:workspace] failed to read workspace packages.\n' +
+        '[auklet:workspace] Expected `pnpm list -r --depth -1 --json` to return package objects with name/path.');
+}

package/dist/workspace/root.d.ts

@@ -0,0 +1 @@
+export declare function findWorkspaceRoot(startDir: string): string | null;

package/dist/workspace/root.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const workspaceFile = 'pnpm-workspace.yaml';
+export function findWorkspaceRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(current, workspaceFile)))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",
@@ -9,8 +9,8 @@
     "pnpm": "=10.27.0"
   },
   "bin": {
-    "auk": "./bin/entry.cjs",
-    "auklet": "./bin/entry.cjs"
+    "auk": "./bin/entry.mjs",
+    "auklet": "./bin/entry.mjs"
   },
   "exports": {
     ".": {
@@ -51,23 +51,29 @@
     "tsdown"
   ],
   "dependencies": {
-    "unrun": "0.3.0",
-    "execa": "9.6.1",
+    "cac": "7.0.0",
+    "tsdown": "0.22.0",
     "aidly": "1.37.0",
+    "execa": "9.6.1",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.0",
     "postcss": "8.5.15",
     "chokidar": "5.0.0",
+    "semver": "7.8.1",
+    "briefing": "0.0.4",
     "minimist": "1.2.8",
+    "picocolors": "1.1.1",
     "typescript": "6.0.3",
+    "prettier": "3.8.3",
     "conditional-export": "1.1.0"
   },
   "devDependencies": {
     "@types/node": "22.17.0",
+    "@types/semver": "7.7.1",
+    "@types/prettier": "3.0.0",
     "@types/minimist": "1.2.5",
     "@vitest/coverage-v8": "4.1.7",
     "husky": "9.1.7",
-    "prettier": "3.8.3",
+    "verdaccio": "6.7.1",
     "lint-staged": "17.0.5",
     "vite": "8.0.14",
     "vitest": "4.1.7"
@@ -89,6 +95,8 @@
     "test:examples": "pnpm build:examples && vitest run examples/__tests__",
     "test:coverage": "vitest run src/__tests__ --coverage",
     "typecheck": "tsc --noEmit --skipLibCheck",
+    "dev:registry": "verdaccio --config examples/verdaccio.yaml --listen 127.0.0.1:4873",
+    "dev:registry-login": "npm adduser --registry http://127.0.0.1:4873 --auth-type=legacy",
     "dev:examples": "pnpm --filter './examples/*' --if-present dev",
     "build:examples": "pnpm --filter './examples/*' build",
     "format:md": "prettier --write \"*.md\" \"examples/**/*.md\"",

package/bin/entry.cjs

@@ -1,163 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('node:fs');
-const path = require('node:path');
-const minimist = require('minimist');
-
-const getPackageVersion = () => {
-  const packageJson = JSON.parse(
-    fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8'),
-  );
-  return packageJson.version;
-};
-
-const runVersion = async () => {
-  console.log(getPackageVersion());
-  return 0;
-};
-
-const loadCurrentAukletConfig = async (options) => {
-  const { loadAukletConfig } = await import('../dist/configLoader.js');
-  return loadAukletConfig(process.cwd(), options);
-};
-
-const runBuildStyle = async (args, options = {}) => {
-  const shouldWatch = args.includes('--watch') || args.includes('-w');
-  const aukletConfig =
-    options.aukletConfig ??
-    (await loadCurrentAukletConfig({
-      cacheBust: shouldWatch,
-    }));
-
-  if (shouldWatch) {
-    const { ModuleStyleWatcher } = await import('../dist/css/watch/watcher.js');
-    const watcher = new ModuleStyleWatcher({ aukletConfig, logger: console });
-    await watcher.watch();
-    const close = () => {
-      watcher
-        .close()
-        .catch(console.error)
-        .finally(() => process.exit(0));
-    };
-    process.once('SIGINT', close);
-    process.once('SIGTERM', close);
-    await new Promise(() => {});
-    return 0;
-  }
-
-  const { ModuleStyleBuilder } =
-    await import('../dist/css/production/builder.js');
-  const builder = new ModuleStyleBuilder({ aukletConfig, logger: console });
-  await builder.build();
-  return 0;
-};
-
-const runBuildJs = async (args) => {
-  const { runTsdown } = await import('../dist/build/runTsdown.js');
-  return runTsdown(args, { cwd: process.cwd() });
-};
-
-const runBuild = async (args) => {
-  const aukletConfig = await loadCurrentAukletConfig();
-  const { cleanAukletOutputByConfig } =
-    await import('../dist/build/cleanOutput.js');
-  cleanAukletOutputByConfig(process.cwd(), aukletConfig);
-
-  const jsExitCode = await runBuildJs(args);
-  if (jsExitCode) return jsExitCode;
-
-  return runBuildStyle([], { aukletConfig });
-};
-
-const runDev = async () => {
-  const { execa } = await import('execa');
-  const { createTsdownArgs } = await import('../dist/build/runTsdown.js');
-  const entries = [
-    createTsdownArgs(['--watch']),
-    [path.resolve(__dirname, './entry.cjs'), 'build-css', '--watch'],
-  ];
-  const processes = entries.map((args) =>
-    execa(process.execPath, args, {
-      cwd: process.cwd(),
-      stdio: 'inherit',
-      reject: false,
-    }),
-  );
-
-  const close = () => {
-    for (const item of processes) {
-      item.kill('SIGTERM');
-    }
-  };
-
-  process.once('SIGINT', close);
-  process.once('SIGTERM', close);
-
-  for (const item of processes) {
-    item.then((result) => {
-      if (result.exitCode) close();
-    });
-  }
-
-  const results = await Promise.all(processes);
-  const failed = results.find((result) => result.exitCode);
-  return failed?.exitCode ?? 0;
-};
-
-const argv = minimist(process.argv.slice(2), {
-  boolean: ['help', 'version'],
-  alias: {
-    h: 'help',
-    v: 'version',
-  },
-});
-const [command, ...args] = argv._;
-const commandIndex = process.argv.indexOf(command);
-const commandArgs =
-  commandIndex >= 0 ? process.argv.slice(commandIndex + 1) : args;
-
-if (argv.version) {
-  console.log(getPackageVersion());
-  process.exit(0);
-}
-
-if (argv.help || !command) {
-  console.log('Usage: auk <command>');
-  console.log('');
-  console.log('Commands:');
-  console.log('  build     Build package JavaScript and CSS output');
-  console.log('  build-js  Build package JavaScript output with tsdown');
-  console.log('  build-css  Build package module CSS output, supports --watch');
-  console.log('  dev       Watch package JavaScript and CSS output');
-  console.log('  version   Print auklet version');
-  console.log('');
-  console.log('Options:');
-  console.log('  -v, --version  Print auklet version');
-  console.log('  -h, --help     Print help');
-  process.exit(argv.help ? 0 : 1);
-}
-
-const runners = {
-  build: runBuild,
-  'build-js': runBuildJs,
-  'build-css': runBuildStyle,
-  dev: runDev,
-  version: runVersion,
-};
-
-const runner = runners[command];
-
-if (runner) {
-  runner(commandArgs)
-    .then((exitCode) => {
-      process.exit(exitCode ?? 0);
-    })
-    .catch((error) => {
-      console.error(error);
-      process.exit(1);
-    });
-  return;
-}
-
-console.error(`Unknown auk command: ${command}`);
-process.exit(1);