auklet 0.1.3 → 0.1.5

package/dist/publish/publishRunner.d.ts

@@ -1,4 +1,4 @@
-import type { PublishOptions } from '#auklet/publish/types';
+import type { PublishOptions, PublishRuntime } from '#auklet/publish/types';
 export declare class PublishRunner {
     private readonly git;
     private readonly publisher;
@@ -6,7 +6,8 @@ export declare class PublishRunner {
     private readonly versions;
     private readonly logger;
     private readonly options;
-    constructor(options: PublishOptions);
+    private readonly runtime;
+    constructor(options: PublishOptions, runtime: PublishRuntime);
     run(): Promise<void>;
     private publishWithPlan;
     private handleFailure;

package/dist/publish/publishRunner.js

@@ -1,4 +1,4 @@
-import { createScopedAukletLogger } from '#auklet/logger';
+import { createAukletLogger } from '#auklet/logger';
 import { runPublishHook } from '#auklet/publish/api/publishHookApi';
 import { runPackageBuilds, validateBuildScript, } from '#auklet/publish/runner/packageBuilder';
 import { formatPublishOutputs } from '#auklet/publish/runner/publishOutputFormatter';
@@ -17,16 +17,18 @@ export class PublishRunner {
     versions;
     logger;
     options;
-    constructor(options) {
+    runtime;
+    constructor(options, runtime) {
         this.options = options;
-        this.logger = createScopedAukletLogger('publish');
+        this.runtime = runtime;
+        this.logger = createAukletLogger({ scope: 'publish' });
         this.git = new ReleaseGitController(this.options, this.logger);
-        this.publisher = new PackagePublisher(this.options, this.logger);
-        this.preflight = new PublishPreflight(this.options, this.logger);
+        this.publisher = new PackagePublisher(this.options, this.runtime, this.logger);
+        this.preflight = new PublishPreflight(this.options, this.runtime, this.logger);
         this.versions = new VersionWriter(this.options, this.logger);
     }
     async run() {
-        const plan = await resolvePublishPlan(this.options, this.logger);
+        const plan = await resolvePublishPlan(this.options, this.runtime, this.logger);
         let failureHookEnabled = false;
         try {
             validateBuildScript(plan.targets);
@@ -36,7 +38,7 @@ export class PublishRunner {
             await runPublishHook({ status: 'beforeBuild', plan });
             failureHookEnabled = true;
             this.versions.writeBeforeBuild(plan);
-            await runPackageBuilds(plan.targets, this.logger, this.options);
+            await runPackageBuilds(plan.targets, this.logger, this.options, this.runtime);
             await runPublishHook({ status: 'afterBuild', plan });
             await formatPublishOutputs(plan.targets, this.options.format);
             await runPublishHook({ status: 'beforePublish', plan });

package/dist/publish/runner/packageBuilder.d.ts

@@ -1,5 +1,4 @@
-import type { PublishTarget } from '#auklet/publish/types';
 import type { AukletLogger } from '#auklet/logger';
-import type { PublishOptions } from '#auklet/publish/types';
+import type { PublishTarget, PublishOptions, PublishRuntime } from '#auklet/publish/types';
 export declare function validateBuildScript(targets: Array<PublishTarget>): void;
-export declare function runPackageBuilds(targets: Array<PublishTarget>, logger: AukletLogger, options?: Pick<PublishOptions, 'token'>): Promise<void>;
+export declare function runPackageBuilds(targets: Array<PublishTarget>, logger: AukletLogger, options: Pick<PublishOptions, 'token'>, runtime: PublishRuntime): Promise<void>;

package/dist/publish/runner/packageBuilder.js

@@ -1,5 +1,6 @@
 import { isString } from 'aidly';
 import { runPnpmBuild } from '#auklet/publish/api/pnpmApi';
+import { createPublishTargetEnv } from '#auklet/publish/publishEnv';
 export function validateBuildScript(targets) {
     for (const target of targets) {
         const buildScript = target.packageJson.scripts?.build;
@@ -8,11 +9,12 @@ export function validateBuildScript(targets) {
         }
     }
 }
-export async function runPackageBuilds(targets, logger, options = {}) {
+export async function runPackageBuilds(targets, logger, options, runtime) {
     for (const target of targets) {
         logger.step('build ', logger.package(target.packageName));
-        if (options.token) {
-            await runPnpmBuild(target.packageRoot, { token: options.token });
+        const { env } = createPublishTargetEnv(options, runtime, target);
+        if (env) {
+            await runPnpmBuild(target.packageRoot, { env });
             continue;
         }
         await runPnpmBuild(target.packageRoot);

package/dist/publish/runner/packagePublisher.d.ts

@@ -1,10 +1,11 @@
 import type { AukletLogger } from '#auklet/logger';
-import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { PublishOptions, PublishPlan, PublishRuntime } from '#auklet/publish/types';
 export declare class PackagePublisher {
     private readonly options;
+    private readonly runtime;
     private readonly logger;
     private readonly pnpm;
-    constructor(options: PublishOptions, logger: AukletLogger);
+    constructor(options: PublishOptions, runtime: PublishRuntime, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
 }
 export declare function logAuthenticationError(logger: AukletLogger, error: unknown): void;

package/dist/publish/runner/packagePublisher.js

@@ -3,17 +3,19 @@ import { NpmPublishAuthenticationError } from '#auklet/publish/api/pnpmApi';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PackagePublisher {
     options;
+    runtime;
     logger;
     pnpm = new PnpmPublishApi();
-    constructor(options, logger) {
+    constructor(options, runtime, logger) {
         this.options = options;
+        this.runtime = runtime;
         this.logger = logger;
     }
     async run(plan) {
         const publishedTargets = [];
         for (const target of plan.targets) {
             try {
-                await this.pnpm.publish(target, this.options);
+                await this.pnpm.publish(target, this.options, this.runtime);
                 publishedTargets.push(target);
             }
             catch (error) {

package/dist/publish/runner/publishPreflight.d.ts

@@ -1,10 +1,11 @@
 import type { AukletLogger } from '#auklet/logger';
-import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { PublishOptions, PublishPlan, PublishRuntime } from '#auklet/publish/types';
 export declare class PublishPreflight {
     private readonly options;
+    private readonly runtime;
     private readonly logger;
     private readonly pnpm;
-    constructor(options: PublishOptions, logger: AukletLogger);
+    constructor(options: PublishOptions, runtime: PublishRuntime, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
     verifyBeforeBuild(plan: PublishPlan): Promise<void>;
     private verifyNpmrcAuthEnv;

package/dist/publish/runner/publishPreflight.js

@@ -1,15 +1,18 @@
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
-import { hasPublishedPackageVersion, NpmPackageVersionExistsError, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
+import { runPnpmWhoami, hasPublishedPackageVersion, NpmPackageVersionExistsError, } from '#auklet/publish/api/pnpmApi';
 import { findNpmrcFiles, findNpmrcWithAuthToken, toNpmrcRegistryKey, validateNpmrcAuthEnv, } from '#auklet/publish/api/npmrc';
 import { getPublishRegistry } from '#auklet/publish/api/registry';
+import { createPublishTargetEnv } from '#auklet/publish/publishEnv';
 import { logAuthenticationError } from '#auklet/publish/runner/packagePublisher';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PublishPreflight {
     options;
+    runtime;
     logger;
     pnpm = new PnpmPublishApi();
-    constructor(options, logger) {
+    constructor(options, runtime, logger) {
         this.options = options;
+        this.runtime = runtime;
         this.logger = logger;
     }
     async run(plan) {
@@ -25,8 +28,9 @@ export class PublishPreflight {
     }
     verifyNpmrcAuthEnv(plan) {
         for (const target of plan.targets) {
+            const { env } = createPublishTargetEnv(this.options, this.runtime, target);
             validateNpmrcAuthEnv(target.packageRoot, plan.root, {
-                token: this.options.token,
+                env,
             });
         }
     }
@@ -51,7 +55,7 @@ export class PublishPreflight {
             await runPnpmWhoami(target.packageRoot, {
                 packageName: target.packageName,
                 registry,
-                token: this.options.token,
+                ...createPublishTargetEnv(this.options, this.runtime, target),
             });
             checked.add(key);
         }
@@ -63,7 +67,7 @@ export class PublishPreflight {
         };
         for (const target of plan.targets) {
             try {
-                await this.pnpm.publish(target, options);
+                await this.pnpm.publish(target, options, this.runtime);
             }
             catch (error) {
                 logAuthenticationError(this.logger, error);
@@ -74,7 +78,10 @@ export class PublishPreflight {
     async verifyPackageVersions(plan) {
         for (const target of plan.targets) {
             const registry = getPublishRegistry(target.packageJson.publishConfig);
-            const exists = await hasPublishedPackageVersion(target.packageRoot, target.packageName, target.publishVersion, { registry, token: this.options.token });
+            const exists = await hasPublishedPackageVersion(target.packageRoot, target.packageName, target.publishVersion, {
+                registry,
+                ...createPublishTargetEnv(this.options, this.runtime, target),
+            });
             if (!exists)
                 continue;
             this.logExistingVersion(target, registry);

package/dist/publish/runner/versionWriter.d.ts

@@ -1,5 +1,5 @@
+import { type AukletLogger } from '#auklet/logger';
 import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
-import type { AukletLogger } from '#auklet/logger';
 export declare class VersionWriter {
     private readonly options;
     private readonly logger;

package/dist/publish/targetResolver.d.ts

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

package/dist/publish/targetResolver.js

@@ -1,13 +1,14 @@
 import path from 'node:path';
 import semver from 'semver';
-import { createScopedAukletLogger } from '#auklet/logger';
 import { findWorkspaceRoot } from '#auklet/workspace/root';
+import { createPublishRootEnv } from '#auklet/publish/publishEnv';
+import { createAukletLogger } from '#auklet/logger';
+import { resolveWorkspacePackageInfos, resolveWorkspaceTargets, } from '#auklet/workspace/targets';
 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')) {
+export async function resolvePublishPlan(options, runtime, logger = createAukletLogger({ scope: 'publish' })) {
     if (options.filters.length) {
-        return resolveMonorepoPublishPlan(options, logger);
+        return resolveMonorepoPublishPlan(options, runtime, logger);
     }
     return resolveCurrentPackagePublishPlan(options);
 }
@@ -17,10 +18,11 @@ export async function resolveOwnerPackageNames(options) {
     }
     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);
+        const packages = await resolveWorkspacePackageInfos(root, options.filters, {
+            scope: 'publish',
+            readErrorMessage: publishWorkspaceReadErrorMessage,
+        });
+        return packages.filter((item) => !item.private).map((item) => item.name);
     }
     if (options.packages.length)
         return [...new Set(options.packages)];
@@ -55,31 +57,33 @@ const resolveCurrentPackagePublishPlan = async (options) => {
         workspaceMode: 'single',
     };
 };
-const resolveMonorepoPublishPlan = async (options, logger) => {
+const resolveMonorepoPublishPlan = async (options, runtime, logger) => {
     const root = requireWorkspaceRoot(options.cwd);
     const rootPackageJson = readPackageJson(root);
     const rootVersion = requirePackageVersion(root, rootPackageJson);
-    const workspacePackages = await readPnpmWorkspacePackages(root, {
+    const { env } = createPublishRootEnv({
         token: options.token,
-    });
-    const selectedPackages = filterWorkspacePackages(workspacePackages, options.filters);
-    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({
+    }, runtime);
+    const targets = await resolveWorkspaceTargets({
+        env,
+        cwd: root,
+        scope: 'publish',
+        readErrorMessage: publishWorkspaceReadErrorMessage,
+        readPackageJson,
+        filters: options.filters,
+        getDependencies: getWorkspaceDependencies,
+        emptyTargetMessage: '[publish] no publishable package found.',
+        createTarget: (item, packageJson) => createPublishTarget({
             packageRoot: item.path,
             packageJson,
             publishVersion: '',
             workspaceMode: 'monorepo',
-        });
+        }),
+        onPrivatePackage: (item, context) => {
+            if (context.exact) {
+                logger.warnOnce('package ', logger.package(item.name), ' is private, skipping.');
+            }
+        },
     });
     const versionBase = getMonorepoVersionBase(rootVersion, targets);
     const publishVersion = await resolvePublishVersion(versionBase, options.version, root);
@@ -96,7 +100,7 @@ const resolveMonorepoPublishPlan = async (options, logger) => {
         root,
         version: publishVersion,
         dryRun: options.dryRun,
-        targets: sortTargetsByWorkspaceDependencies(publishTargets),
+        targets: publishTargets,
         config: getPublishConfig(rootPackageJson),
         workspaceMode: 'monorepo',
     };
@@ -118,23 +122,6 @@ const requireWorkspaceRoot = (cwd) => {
     }
     return root;
 };
-const filterWorkspacePackages = (packages, filters) => {
-    const matched = packages.filter((item) => filters.some((filter) => matchesFilter(item.name, filter)));
-    if (!matched.length) {
-        throw new Error(`[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);
@@ -155,39 +142,10 @@ const validatePublishTargets = (targets) => {
         throw new Error('[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(`[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) => {
+const getWorkspaceDependencies = (target) => {
     return Object.entries({
-        ...packageJson.dependencies,
-        ...packageJson.optionalDependencies,
+        ...target.packageJson.dependencies,
+        ...target.packageJson.optionalDependencies,
     })
         .filter(([, version]) => version === 'workspace:*')
         .map(([packageName]) => packageName);
@@ -211,3 +169,4 @@ const workspaceDependencyGroups = [
     'optionalDependencies',
     'peerDependencies',
 ];
+const publishWorkspaceReadErrorMessage = '[publish] failed to read pnpm workspace packages.';

package/dist/publish/types.d.ts

@@ -1,3 +1,5 @@
+import type { AukletEnvContext } from '#auklet/env';
+import type { DeferredCliValue } from '#auklet/cli/parse/values';
 export type PackageJson = {
     name?: string;
     version?: string;
@@ -35,12 +37,6 @@ export type PublishTarget = {
     workspaceMode: 'single' | 'monorepo';
     packageJson: PackageJson;
 };
-export type WorkspacePackage = {
-    name: string;
-    path: string;
-    version: string;
-    private?: boolean;
-};
 export type PublishOptions = {
     cwd: string;
     dryRun: boolean;
@@ -50,9 +46,12 @@ export type PublishOptions = {
     filters: Array<string>;
     git?: boolean;
     otp?: string;
-    token?: string;
+    token?: DeferredCliValue;
     version?: string;
 };
+export type PublishRuntime = {
+    envContext: AukletEnvContext;
+};
 export type OwnerOptions = {
     cwd: string;
     users: Array<string>;

package/dist/workspace/targets.d.ts

@@ -0,0 +1,31 @@
+import type { WorkspacePackageInfo } from '#auklet/workspace/packages';
+type WorkspaceTargetBase<T> = {
+    private?: boolean;
+    packageJson: T;
+    packageName: string;
+};
+type ResolveWorkspaceTargetsOptions<T, TTarget> = {
+    cwd: string;
+    scope: string;
+    filters: Array<string>;
+    emptyTargetMessage: string;
+    excludeRoot?: boolean;
+    includePrivate?: boolean;
+    readErrorMessage?: string;
+    includeDependencies?: boolean;
+    env?: Record<string, string | undefined>;
+    readPackageJson: (packageRoot: string) => T;
+    getDependencies: (target: TTarget) => Array<string>;
+    createTarget: (item: WorkspacePackageInfo, packageJson: T) => TTarget;
+    onPrivatePackage?: (item: WorkspacePackageInfo, context: {
+        exact: boolean;
+    }) => void;
+};
+export declare function resolveWorkspacePackageInfos(cwd: string, filters: Array<string>, options: {
+    env?: Record<string, string | undefined>;
+    scope: string;
+    readErrorMessage?: string;
+}): Promise<WorkspacePackageInfo[]>;
+export declare function resolveWorkspaceTargets<T, K extends WorkspaceTargetBase<T>>(options: ResolveWorkspaceTargetsOptions<T, K>): Promise<K[]>;
+export declare function getWorkspaceDependencyNames(value: unknown): string[];
+export {};

package/dist/workspace/targets.js

@@ -0,0 +1,144 @@
+import path from 'node:path';
+import { isPlainObject } from 'aidly';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
+import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
+export async function resolveWorkspacePackageInfos(cwd, filters, options) {
+    const root = requireWorkspaceRoot(cwd, options.scope);
+    const packages = await readWorkspacePackageInfo(root, options);
+    return filterWorkspacePackages(packages, filters, options.scope);
+}
+export async function resolveWorkspaceTargets(options) {
+    const root = requireWorkspaceRoot(options.cwd, options.scope);
+    const packages = filterWorkspaceRootPackage(await readWorkspacePackageInfo(root, options), root, options);
+    const matchedPackages = filterWorkspacePackages(packages, options.filters, options.scope);
+    const targetFactory = createWorkspaceTargetFactory(options);
+    const targets = options.includeDependencies
+        ? includeWorkspaceDependencies(matchedPackages, packages, targetFactory, options)
+        : matchedPackages
+            .map((item) => targetFactory.create(item))
+            .filter(isWorkspaceTarget);
+    if (!targets.length) {
+        throw new Error(options.emptyTargetMessage);
+    }
+    return sortWorkspaceTargets(targets, {
+        getDependencies: options.getDependencies,
+        scope: options.scope,
+    });
+}
+export function getWorkspaceDependencyNames(value) {
+    return isPlainObject(value) ? Object.keys(value) : [];
+}
+const filterWorkspaceRootPackage = (packages, root, options) => {
+    if (!options.excludeRoot)
+        return packages;
+    const normalizedRoot = path.resolve(root);
+    return packages.filter((item) => path.resolve(item.path) !== normalizedRoot);
+};
+const isWorkspaceTarget = (target) => {
+    return target !== null;
+};
+const createWorkspaceTargetFactory = (options) => {
+    const cache = new Map();
+    const create = (item) => {
+        const cached = cache.get(item.name);
+        if (cached !== undefined)
+            return cached;
+        if (!options.includePrivate && item.private) {
+            options.onPrivatePackage?.(item, {
+                exact: options.filters.includes(item.name),
+            });
+            cache.set(item.name, null);
+            return null;
+        }
+        const packageJson = options.readPackageJson(item.path);
+        const target = options.createTarget(item, packageJson);
+        cache.set(item.name, target);
+        return target;
+    };
+    return { create };
+};
+const includeWorkspaceDependencies = (matchedPackages, packages, targetFactory, options) => {
+    const packageMap = new Map(packages.map((item) => [item.name, item]));
+    const included = new Map();
+    const include = (item) => {
+        const target = targetFactory.create(item);
+        if (!target || included.has(target.packageName))
+            return;
+        included.set(target.packageName, target);
+        for (const dependency of options.getDependencies(target)) {
+            const dependencyItem = packageMap.get(dependency);
+            if (dependencyItem)
+                include(dependencyItem);
+        }
+    };
+    for (const item of matchedPackages) {
+        include(item);
+    }
+    return [...included.values()];
+};
+const requireWorkspaceRoot = (cwd, scope) => {
+    const root = findWorkspaceRoot(cwd);
+    if (!root) {
+        throw new Error(`[${scope}] --filter requires a pnpm workspace root.`);
+    }
+    return root;
+};
+const readWorkspacePackageInfo = async (root, options) => {
+    try {
+        return await readPnpmWorkspacePackageInfo(root, {
+            env: options.env,
+        });
+    }
+    catch (error) {
+        if (!options.readErrorMessage)
+            throw error;
+        throw new Error(options.readErrorMessage, {
+            cause: error,
+        });
+    }
+};
+const filterWorkspacePackages = (packages, filters, scope) => {
+    const matched = packages.filter((item) => filters.some((filter) => matchesWorkspacePackageFilter(item.name, filter)));
+    if (!matched.length) {
+        throw new Error(`[${scope}] no workspace package matched filter: ${filters.join(', ')}`);
+    }
+    return matched;
+};
+const matchesWorkspacePackageFilter = (packageName, filter) => {
+    if (filter === '*')
+        return true;
+    if (filter.endsWith('/*')) {
+        const scope = filter.slice(0, -2);
+        return packageName.startsWith(`${scope}/`);
+    }
+    return packageName === filter;
+};
+const sortWorkspaceTargets = (targets, options) => {
+    const targetNames = new Set(targets.map((target) => target.packageName));
+    const targetMap = new Map(targets.map((target) => [target.packageName, target]));
+    const sorted = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = (target) => {
+        if (visited.has(target.packageName))
+            return;
+        if (visiting.has(target.packageName)) {
+            throw new Error(`[${options.scope}] circular workspace dependency detected at ${target.packageName}.`);
+        }
+        visiting.add(target.packageName);
+        for (const dependency of options.getDependencies(target)) {
+            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;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",

package/dist/cli/buildArgs.d.ts

@@ -1,8 +0,0 @@
-import type { AukletConfig } from '#auklet/types';
-export declare function resolveBuildCliArgs(args: Array<string>): {
-    args: string[];
-    config: AukletConfig;
-};
-export declare function createBuildEnv(config: AukletConfig): {
-    AUKLET_CONFIG_OVERRIDES: string;
-} | undefined;