auklet 0.1.4 → 0.1.5

package/dist/publish/cli.js

@@ -1,154 +1,37 @@
-import minimist from 'minimist';
-import { isArray } from 'aidly';
 import { AukletEnvContext } from '#auklet/env';
 import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
 import { OwnerRunner } from '#auklet/publish/ownerRunner';
 import { PublishRunner } from '#auklet/publish/publishRunner';
 import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
-import { resolveCliBoolean, resolveCliValue, createDeferredCliValue, } from '#auklet/cli/values';
 import { createPublishRootEnv } from '#auklet/publish/publishEnv';
 import { findWorkspaceRoot } from '#auklet/workspace/root';
-const publishFlags = new Set([
-    '_',
-    'filter',
-    'version',
-    'dry-run',
-    'format',
-    'git',
-    'otp',
-    'token',
-    'ignore-scripts',
-    'allow-dirty',
-]);
-const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
+import { parseOwnerCommand } from '#auklet/cli/parse/owner';
+import { parsePublishCommand } from '#auklet/cli/parse/publish';
 export async function runPublishCli(args) {
     const cwd = process.cwd();
     const root = findWorkspaceRoot(cwd) ?? cwd;
     const envContext = new AukletEnvContext(cwd, root);
     await envContext.run(async () => {
         const runtime = { envContext };
-        const options = resolvePublishCliOptions(args, cwd, envContext);
+        const options = parsePublishCommand(args, { cwd, envContext });
         const { env } = createPublishRootEnv(options, runtime);
         validatePublishCliNpmrcAuthEnv(options.cwd, env);
         await ensurePnpm({ env });
         await new PublishRunner(options, runtime).run();
     });
 }
-export function resolvePublishCliOptions(args, cwd = process.cwd(), envContext = new AukletEnvContext(cwd)) {
-    const argv = parsePublishArgs(args);
-    if (argv._.length) {
-        throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
-    }
-    return {
-        cwd,
-        otp: stringOption(argv.otp, '--otp', envContext),
-        filters: toArray(argv.filter, '--filter', envContext),
-        version: stringOption(argv.version, '--version', envContext),
-        git: booleanOption(argv.git, '--git', envContext, true),
-        format: booleanOption(argv.format, '--format', envContext, true),
-        dryRun: booleanOption(argv['dry-run'], '--dry-run', envContext),
-        allowDirty: booleanOption(argv['allow-dirty'], '--allow-dirty', envContext),
-        ignoreScripts: booleanOption(argv['ignore-scripts'], '--ignore-scripts', envContext),
-        token: deferredStringOption(argv.token, '--token'),
-    };
-}
-const parsePublishArgs = (args) => {
-    const cliArgs = stripLeadingArgsSeparator(args);
-    validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']));
-    const argv = minimist(cliArgs, {
-        string: [
-            'filter',
-            'version',
-            'otp',
-            'token',
-            'dry-run',
-            'format',
-            'git',
-            'ignore-scripts',
-            'allow-dirty',
-        ],
-    });
-    validateFlags(argv, publishFlags);
-    return argv;
-};
 export async function runOwnerCli(args) {
     const cwd = process.cwd();
     const root = findWorkspaceRoot(cwd) ?? cwd;
     const envContext = new AukletEnvContext(cwd, root);
     await envContext.run(async () => {
-        const cliArgs = stripLeadingArgsSeparator(args);
-        validateNoPrefixedFlags(cliArgs, new Set());
-        const argv = minimist(cliArgs, {
-            string: ['filter', 'package', 'otp'],
-        });
-        validateFlags(argv, ownerFlags);
-        const [subcommand, ...users] = argv._;
-        if (subcommand !== 'add') {
-            throw new Error('[publish] expected owner command: auk owner add <user...>');
-        }
-        if (!users.length) {
-            throw new Error('[publish] owner add requires at least one user.');
-        }
+        const options = parseOwnerCommand(args, { cwd, envContext });
         const env = envContext.values;
         validatePublishCliNpmrcAuthEnv(cwd, env);
         await ensurePnpm({ env: envContext.normalizedValues });
-        await new OwnerRunner({
-            cwd,
-            users,
-            filters: toArray(argv.filter, '--filter', envContext),
-            packages: toArray(argv.package, '--package', envContext),
-            otp: stringOption(argv.otp, '--otp', envContext),
-        }).run();
+        await new OwnerRunner(options).run();
     });
 }
-const validateFlags = (argv, allowedFlags) => {
-    for (const flag of Object.keys(argv)) {
-        if (!allowedFlags.has(flag)) {
-            throw new Error(`[publish] unknown option: --${flag}`);
-        }
-    }
-};
-const validateNoPrefixedFlags = (args, allowedFlags) => {
-    const flag = args.find((arg) => arg.startsWith('--no-') && !allowedFlags.has(arg));
-    if (flag) {
-        throw new Error(`[publish] unknown option: ${flag}`);
-    }
-};
-const stripLeadingArgsSeparator = (args) => {
-    return args.filter((arg) => arg !== '--');
-};
-const toArray = (value, label, envContext) => {
-    if (value === undefined)
-        return [];
-    const values = isArray(value)
-        ? value.map((item) => stringOption(item, label, envContext)).filter(Boolean)
-        : [stringOption(value, label, envContext)].filter(Boolean);
-    return values.filter((item) => Boolean(item));
-};
-const stringOption = (value, label, envContext) => {
-    if (value === undefined)
-        return undefined;
-    if (isArray(value))
-        return stringOption(value.at(-1), label, envContext);
-    return resolveCliValue(String(value), { label, context: envContext });
-};
-const deferredStringOption = (value, label) => {
-    if (value === undefined)
-        return undefined;
-    if (isArray(value))
-        return deferredStringOption(value.at(-1), label);
-    return createDeferredCliValue(String(value), { label });
-};
-const booleanOption = (value, label, envContext, defaultValue = false) => {
-    if (value === undefined)
-        return defaultValue;
-    if (isArray(value)) {
-        return booleanOption(value.at(-1), label, envContext, defaultValue);
-    }
-    if (typeof value === 'boolean')
-        return value;
-    return resolveCliBoolean(String(value), { label, context: envContext });
-};
 const validatePublishCliNpmrcAuthEnv = (cwd, env) => {
     validateNpmrcAuthEnv(cwd, findWorkspaceRoot(cwd) ?? cwd, { env });
 };

package/dist/publish/inspect.js

@@ -6,7 +6,7 @@ import { findWorkspaceRoot } from '#auklet/workspace/root';
 import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
 import { getPublishRegistry } from '#auklet/publish/api/registry';
 import { resolvePublishTag } from '#auklet/publish/api/publishArgs';
-import { resolvePublishCliOptions } from '#auklet/publish/cli';
+import { parsePublishCommand } from '#auklet/cli/parse/publish';
 import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
 import { createPublishRootEnv } from '#auklet/publish/publishEnv';
 import { inspectPublishRegistry, } from '#auklet/publish/inspectRegistry';
@@ -17,7 +17,7 @@ export async function runInspectPublishCli(args) {
     const root = findWorkspaceRoot(cwd) ?? cwd;
     const envContext = new AukletEnvContext(cwd, root);
     return envContext.run(async () => {
-        const options = resolvePublishCliOptions(args, cwd, envContext);
+        const options = parsePublishCommand(args, { cwd, envContext });
         return runInspectPublish(options, root, { envContext });
     });
 }

package/dist/publish/targetResolver.js

@@ -3,8 +3,8 @@ import semver from 'semver';
 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, runtime, logger = createAukletLogger({ scope: 'publish' })) {
     if (options.filters.length) {
@@ -18,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)];
@@ -63,27 +64,26 @@ const resolveMonorepoPublishPlan = async (options, runtime, logger) => {
     const { env } = createPublishRootEnv({
         token: options.token,
     }, runtime);
-    const workspacePackages = await readPnpmWorkspacePackages(root, {
+    const targets = await resolveWorkspaceTargets({
         env,
-    });
-    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({
+        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);
@@ -100,7 +100,7 @@ const resolveMonorepoPublishPlan = async (options, runtime, logger) => {
         root,
         version: publishVersion,
         dryRun: options.dryRun,
-        targets: sortTargetsByWorkspaceDependencies(publishTargets),
+        targets: publishTargets,
         config: getPublishConfig(rootPackageJson),
         workspaceMode: 'monorepo',
     };
@@ -122,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);
@@ -159,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);
@@ -215,3 +169,4 @@ const workspaceDependencyGroups = [
     'optionalDependencies',
     'peerDependencies',
 ];
+const publishWorkspaceReadErrorMessage = '[publish] failed to read pnpm workspace packages.';

package/dist/publish/types.d.ts

@@ -1,5 +1,5 @@
 import type { AukletEnvContext } from '#auklet/env';
-import type { DeferredCliValue } from '#auklet/cli/values';
+import type { DeferredCliValue } from '#auklet/cli/parse/values';
 export type PackageJson = {
     name?: string;
     version?: string;
@@ -37,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;

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.4",
+  "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,9 +0,0 @@
-import { AukletEnvContext } from '#auklet/env';
-import type { AukletConfig } from '#auklet/types';
-export declare function resolveBuildCliArgs(args: Array<string>, envContext?: AukletEnvContext): {
-    args: string[];
-    config: AukletConfig;
-};
-export declare function createBuildEnv(config: AukletConfig): {
-    AUKLET_CONFIG_OVERRIDES: string;
-} | undefined;

package/dist/cli/publish.d.ts

@@ -1,2 +0,0 @@
-export declare function runPublish(args: Array<string>): Promise<number>;
-export declare function runOwner(args: Array<string>): Promise<number>;

package/dist/cli/publish.js

@@ -1,9 +0,0 @@
-import { runOwnerCli, runPublishCli } from '#auklet/publish/cli';
-export async function runPublish(args) {
-    await runPublishCli(args);
-    return 0;
-}
-export async function runOwner(args) {
-    await runOwnerCli(args);
-    return 0;
-}