auklet 0.0.18 → 0.0.20

package/dist/publish/runner/versionWriter.js

@@ -0,0 +1,78 @@
+import { readPackageJson, writePackageJson, } from '#auklet/publish/api/packageJsonApi';
+export class VersionWriter {
+    options;
+    logger;
+    constructor(options, logger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    writeBeforeBuild(plan) {
+        if (!plan.dryRun && this.options.version) {
+            this.writeVersions(plan);
+        }
+    }
+    logDryRunPlan(plan) {
+        if (!plan.dryRun || !this.options.version)
+            return;
+        const logger = this.logger;
+        logger.info('dry-run mode: package.json files will not be changed');
+        if (plan.workspaceMode === 'monorepo') {
+            const rootPackageJson = readPackageJson(plan.root);
+            logger.summary({
+                title: 'Publish dry-run plan',
+                values: {
+                    mode: plan.workspaceMode,
+                    sharedVersion: this.formatVersionChange(rootPackageJson.version, plan.version),
+                    targets: plan.targets.length,
+                },
+            });
+            for (const target of plan.targets) {
+                logger.info('planned package ', this.formatPackage(target.packageName), ': ', ...this.formatVersionChange(target.version, target.publishVersion));
+            }
+            logger.info('builds will still read each package.json#version');
+            logger.info('pnpm publish --dry-run will still read each package.json#version');
+            return;
+        }
+        const [target] = plan.targets;
+        if (target) {
+            logger.summary({
+                title: 'Publish dry-run plan',
+                values: {
+                    package: this.formatPackage(target.packageName),
+                    version: this.formatVersionChange(target.version, target.publishVersion),
+                },
+            });
+            logger.info(`build will still read package.json#version: ${target.version}`);
+            logger.info(`pnpm publish --dry-run will still read package.json#version: ${target.version}`);
+        }
+    }
+    logWrittenVersionFailure(plan) {
+        if (!plan.dryRun && this.options.version) {
+            this.logger.error('package.json versions may have been written. Auklet will not roll them back; check publish output before retrying.');
+        }
+    }
+    writeVersions(plan) {
+        const packageRoots = new Set([
+            plan.root,
+            ...plan.targets.map((target) => target.packageRoot),
+        ]);
+        for (const packageRoot of packageRoots) {
+            const packageJson = readPackageJson(packageRoot);
+            const packageName = plan.targets.find((target) => target.packageRoot === packageRoot)
+                ?.packageName ?? (packageRoot === plan.root ? 'root' : packageRoot);
+            if (packageJson.version !== plan.version) {
+                this.logger.info('writing version ', this.formatPackage(packageName), ': ', ...this.formatVersionChange(packageJson.version, plan.version));
+            }
+            packageJson.version = plan.version;
+            writePackageJson(packageRoot, packageJson);
+        }
+    }
+    formatPackage(packageName) {
+        return this.logger.package(packageName);
+    }
+    formatVersionChange(from, to) {
+        const logger = this.logger;
+        const fromVersion = String(from);
+        return [logger.version(fromVersion), ' -> ', logger.version(to)];
+    }
+}

package/dist/publish/targetResolver.d.ts

@@ -0,0 +1,7 @@
+import { type AukletLogger } from '#auklet/logger';
+import type { OwnerOptions, PublishOptions, PublishPlan } from '#auklet/publish/types';
+type ResolvePublishTargetsOptions = Pick<PublishOptions, 'cwd' | 'filters' | 'version' | 'dryRun'>;
+type ResolveOwnerTargetsOptions = Pick<OwnerOptions, 'cwd' | 'filters' | 'packages'>;
+export declare function resolvePublishPlan(options: ResolvePublishTargetsOptions, logger?: AukletLogger): Promise<PublishPlan>;
+export declare function resolveOwnerPackageNames(options: ResolveOwnerTargetsOptions): Promise<string[]>;
+export {};

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.18",
+  "version": "0.0.20",
   "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,30 @@
     "tsdown"
   ],
   "dependencies": {
+    "cac": "7.0.0",
     "unrun": "0.3.0",
-    "execa": "9.6.1",
+    "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 +96,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\"",