auklet 0.1.4 → 0.1.6

package/dist/cli/parse/workspace.js

@@ -0,0 +1,60 @@
+import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/parse/values';
+import { dedupe, readFlagValue, readOptionalFlagValue, } from '#auklet/cli/parse/core';
+export function parseWorkspaceSelectionArgs(args, envContext) {
+    const filters = [];
+    const remainingArgs = [];
+    let includePrivate = false;
+    let includeDependencies = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const [name, inlineValue] = arg.split('=', 2);
+        if (name === '--workspace') {
+            if (inlineValue !== undefined) {
+                throw new Error('--workspace does not accept a value.');
+            }
+            filters.push('*');
+            continue;
+        }
+        if (name === '--filter') {
+            filters.push(resolveCliValue(readFlagValue(args, index, inlineValue, name), {
+                label: name,
+                context: envContext,
+            }));
+            if (inlineValue === undefined)
+                index += 1;
+            continue;
+        }
+        if (name === '--deps') {
+            const result = readWorkspaceBooleanFlag(args, index, inlineValue, name, envContext);
+            includeDependencies = result.value;
+            if (result.consumedNext)
+                index += 1;
+            continue;
+        }
+        if (name === '--private') {
+            const result = readWorkspaceBooleanFlag(args, index, inlineValue, name, envContext);
+            includePrivate = result.value;
+            if (result.consumedNext)
+                index += 1;
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    return {
+        remainingArgs,
+        workspace: {
+            filters: dedupe(filters),
+            includeDependencies,
+            includePrivate,
+        },
+    };
+}
+const readWorkspaceBooleanFlag = (args, index, inlineValue, name, envContext) => {
+    const value = readOptionalFlagValue(args, index, inlineValue);
+    return {
+        consumedNext: inlineValue === undefined && value !== undefined,
+        value: value === undefined
+            ? true
+            : resolveCliBoolean(value, { label: name, context: envContext }),
+    };
+};

package/dist/css/inspect.js

@@ -3,7 +3,8 @@ import { readFileSync } from 'node:fs';
 import { isPlainObject, isString } from 'aidly';
 import { normalizeAukletConfig } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
-import { resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { parseBuildOverrideArgs } from '#auklet/cli/parse/build';
+import { AukletEnvContext } from '#auklet/env';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
 import { createExternalEntryParts, createModuleStyleEntryPlans, createStyleEntryParts, createThemeEntryParts, } from '#auklet/css/core/style/entries';
@@ -20,11 +21,11 @@ export async function runInspectCssCli(args) {
     return 0;
 }
 export async function resolveInspectCssOptions(args) {
-    const buildArgs = resolveBuildCliArgs(args.filter((arg) => arg !== '--'));
+    const cwd = process.cwd();
+    const buildArgs = parseBuildOverrideArgs(args.filter((arg) => arg !== '--'), new AukletEnvContext(cwd));
     if (buildArgs.args.length) {
         throw new Error(`[inspect] unknown inspect css argument: ${buildArgs.args[0]}`);
     }
-    const cwd = process.cwd();
     const workspaceRoot = findWorkspaceRoot(cwd);
     const packageRoots = workspaceRoot === cwd
         ? (await readPnpmWorkspacePackageInfo(cwd))

package/dist/publish/api/pnpmApi.d.ts

@@ -1,5 +1,4 @@
 import { execa, type Options } from 'execa';
-import type { WorkspacePackage } from '#auklet/publish/types';
 export declare class NpmPublishAuthenticationError extends Error {
     readonly packageRoot: string;
     constructor(packageRoot: string);
@@ -11,9 +10,6 @@ export declare function withPnpmTimeout(subprocess: ReturnType<typeof execa>, ti
 export declare function ensurePnpm(options?: {
     env?: Record<string, string | undefined>;
 }): Promise<string>;
-export declare function readPnpmWorkspacePackages(root: string, options?: {
-    env?: Record<string, string | undefined>;
-}): Promise<WorkspacePackage[]>;
 export declare function runPnpmBuild(packageRoot: string, options?: {
     env?: Record<string, string | undefined>;
 }): Promise<void>;

package/dist/publish/api/pnpmApi.js

@@ -1,7 +1,5 @@
-import { isPlainObject, isString } from 'aidly';
 import { execa } from 'execa';
 import semver from 'semver';
-import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
 const supportedPnpmRange = '>=10.0.0';
 export class NpmPublishAuthenticationError extends Error {
     packageRoot;
@@ -68,22 +66,6 @@ export async function ensurePnpm(options = {}) {
     }
     return version;
 }
-export async function readPnpmWorkspacePackages(root, options = {}) {
-    try {
-        return (await readPnpmWorkspacePackageInfo(root, {
-            env: options.env,
-        })).map((item) => {
-            if (!isWorkspacePackage(item))
-                throwInvalidWorkspacePackages();
-            return item;
-        });
-    }
-    catch (error) {
-        throw new Error('[publish] failed to read pnpm workspace packages.', {
-            cause: error,
-        });
-    }
-}
 export async function runPnpmBuild(packageRoot, options = {}) {
     const result = await runPnpm(['run', 'build'], {
         cwd: packageRoot,
@@ -159,18 +141,6 @@ export async function runPnpmOwnerAdd(packageName, user, options) {
         throw new Error(`[publish] pnpm owner add failed for ${user} -> ${packageName}.`);
     }
 }
-const isWorkspacePackage = (value) => {
-    if (!isPlainObject(value)) {
-        return false;
-    }
-    return (isString(value.name) &&
-        value.name.length > 0 &&
-        isString(value.path) &&
-        value.path.length > 0 &&
-        isString(value.version) &&
-        value.version.length > 0 &&
-        (value.private === undefined || typeof value.private === 'boolean'));
-};
 const hasFailedPnpmResult = (result) => {
     return result.failed === true || result.exitCode !== 0;
 };
@@ -181,10 +151,6 @@ const getPnpmFailureReason = (result) => {
     const stdout = String(result.stdout ?? '').trim();
     return stdout || null;
 };
-function throwInvalidWorkspacePackages() {
-    throw new Error('[publish] failed to read pnpm workspace packages.\n' +
-        '[publish] Expected `pnpm list -r --depth -1 --json` to return package objects with name/path/version.');
-}
 export function hasNpmAuthChallenge(result) {
     const output = [result.stdout, result.stderr]
         .map((value) => String(value ?? ''))

package/dist/publish/cli.d.ts

@@ -1,18 +1,2 @@
-import { AukletEnvContext } from '#auklet/env';
 export declare function runPublishCli(args: Array<string>): Promise<void>;
-export declare function resolvePublishCliOptions(args: Array<string>, cwd?: string, envContext?: AukletEnvContext): {
-    cwd: string;
-    otp: string | undefined;
-    filters: string[];
-    version: string | undefined;
-    git: boolean;
-    format: boolean;
-    dryRun: boolean;
-    allowDirty: boolean;
-    ignoreScripts: boolean;
-    token: {
-        raw: string;
-        resolve(context: AukletEnvContext): string | undefined;
-    } | undefined;
-};
 export declare function runOwnerCli(args: Array<string>): Promise<void>;

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,13 +18,15 @@ 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)
+    if (options.packages.length) {
         return [...new Set(options.packages)];
+    }
     const packageJson = readPackageJson(options.cwd);
     if (packageJson.private) {
         throw new Error('[publish] current package is private.');
@@ -63,27 +65,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 +101,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 +123,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 +143,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 +170,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 {};