auklet 0.1.4 → 0.1.5

package/dist/cli/{buildArgs.js → parse/build.js}

@@ -1,13 +1,48 @@
 import { hasTsdownConfigArg } from '#auklet/build/runTsdown';
 import { aukletCliConfigOverridesEnv, encodeAukletCliConfigOverrides, } from '#auklet/build/cliOverrides';
-import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/values';
-import { AukletEnvContext } from '#auklet/env';
+import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/parse/values';
+import { readFlagValue, readOptionalFlagValue } from '#auklet/cli/parse/core';
+import { parseWorkspaceSelectionArgs } from '#auklet/cli/parse/workspace';
 const buildFormats = new Set(['cjs', 'esm', 'iife']);
 const buildPlatforms = new Set(['node', 'neutral', 'browser']);
 const hasAukletConfig = (config) => {
     return Object.keys(config).length > 0;
 };
-export function resolveBuildCliArgs(args, envContext = new AukletEnvContext(process.cwd())) {
+export function parseBuildCommand(args, options) {
+    const workspaceArgs = parseWorkspaceSelectionArgs(args, options.envContext);
+    const buildArgs = parseBuildOverrideArgs(workspaceArgs.remainingArgs, options.envContext);
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        workspace: workspaceArgs.workspace,
+        overrides: buildArgs.config,
+        passthroughArgs: buildArgs.args,
+        workspaceScriptArgs: workspaceArgs.remainingArgs,
+    };
+}
+export function parseBuildJsCommand(args, options) {
+    const buildArgs = parseBuildOverrideArgs(args, options.envContext);
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: buildArgs.config,
+        passthroughArgs: buildArgs.args,
+    };
+}
+export function parseBuildCssCommand(args, options) {
+    const buildArgs = parseBuildOverrideArgs(args, options.envContext);
+    const remainingArgs = buildArgs.args.filter((arg) => arg !== '--watch' && arg !== '-w');
+    if (remainingArgs.length) {
+        throw new Error(`[build-css] unknown build-css argument: ${remainingArgs[0]}`);
+    }
+    return {
+        cwd: options.cwd,
+        envContext: options.envContext,
+        overrides: buildArgs.config,
+        watch: buildArgs.args.includes('--watch') || buildArgs.args.includes('-w'),
+    };
+}
+export function parseBuildOverrideArgs(args, envContext) {
     const remainingArgs = [];
     const config = {};
     for (let index = 0; index < args.length; index += 1) {
@@ -26,7 +61,7 @@ export function resolveBuildCliArgs(args, envContext = new AukletEnvContext(proc
             continue;
         }
         if (name === '--modules') {
-            const value = getOptionalFlagValue(args, index, inlineValue);
+            const value = readOptionalFlagValue(args, index, inlineValue);
             config.modules =
                 value === undefined
                     ? true
@@ -42,7 +77,12 @@ export function resolveBuildCliArgs(args, envContext = new AukletEnvContext(proc
         if (name === '--build.formats') {
             config.build = {
                 ...config.build,
-                formats: parseBuildFormats(getResolvedFlagValue(args, index, inlineValue, name, envContext)),
+                formats: parseBuildFormats(inlineValue === undefined
+                    ? getResolvedFlagValue(args, index, inlineValue, name, envContext)
+                    : (resolveCliValue(inlineValue, {
+                        label: name,
+                        context: envContext,
+                    }) ?? inlineValue)),
             };
             if (inlineValue === undefined)
                 index += 1;
@@ -92,23 +132,8 @@ export function createBuildEnv(config) {
         [aukletCliConfigOverridesEnv]: encodeAukletCliConfigOverrides(config),
     };
 }
-const getFlagValue = (args, index, inlineValue, flag) => {
-    const value = inlineValue ?? args[index + 1];
-    if (!value || value.startsWith('--')) {
-        throw new Error(`${flag} requires a value.`);
-    }
-    return value;
-};
-const getOptionalFlagValue = (args, index, inlineValue) => {
-    if (inlineValue !== undefined)
-        return inlineValue;
-    const value = args[index + 1];
-    if (!value || value.startsWith('--'))
-        return undefined;
-    return value;
-};
 const getResolvedFlagValue = (args, index, inlineValue, flag, envContext) => {
-    return resolveCliValue(getFlagValue(args, index, inlineValue, flag), {
+    return resolveCliValue(readFlagValue(args, index, inlineValue, flag), {
         label: flag,
         context: envContext,
     });
@@ -116,7 +141,7 @@ const getResolvedFlagValue = (args, index, inlineValue, flag, envContext) => {
 const parseBuildFormats = (value) => {
     const formats = value
         .split(',')
-        .map((format) => format.trim())
+        .map((item) => item.trim())
         .filter(Boolean);
     if (!formats.length) {
         throw new Error('--build.formats requires at least one format.');

package/dist/cli/parse/core.d.ts

@@ -0,0 +1,14 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function stripArgsSeparator(args: Array<string>): string[];
+export declare function readFlagValue(args: Array<string>, index: number, inlineValue: string | undefined, flag: string): string;
+export declare function readOptionalFlagValue(args: Array<string>, index: number, inlineValue: string | undefined): string | undefined;
+export declare function dedupe<T>(items: Array<T>): T[];
+export declare function stringOption(value: unknown, label: string, envContext: AukletEnvContext): string | undefined;
+export declare function deferredStringOption(value: unknown, label: string): {
+    raw: string;
+    resolve(context: AukletEnvContext): string | undefined;
+} | undefined;
+export declare function booleanOption(value: unknown, label: string, envContext: AukletEnvContext, defaultValue?: boolean): boolean;
+export declare function stringArrayOption(value: unknown, label: string, envContext: AukletEnvContext): string[];
+export declare function validateUnknownFlags(argv: Record<string, unknown>, allowedFlags: Set<string>, scope: string): void;
+export declare function validateNoPrefixedFlags(args: Array<string>, allowedFlags: Set<string>, scope: string): void;

package/dist/cli/parse/core.js

@@ -0,0 +1,68 @@
+import { isArray } from 'aidly';
+import { createDeferredCliValue, resolveCliBoolean, resolveCliValue, } from '#auklet/cli/parse/values';
+export function stripArgsSeparator(args) {
+    return args.filter((arg) => arg !== '--');
+}
+export function readFlagValue(args, index, inlineValue, flag) {
+    const value = inlineValue ?? args[index + 1];
+    if (!value || value.startsWith('--')) {
+        throw new Error(`${flag} requires a value.`);
+    }
+    return value;
+}
+export function readOptionalFlagValue(args, index, inlineValue) {
+    if (inlineValue !== undefined)
+        return inlineValue;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--'))
+        return undefined;
+    return value;
+}
+export function dedupe(items) {
+    return [...new Set(items)];
+}
+export function 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 });
+}
+export function deferredStringOption(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (isArray(value))
+        return deferredStringOption(value.at(-1), label);
+    return createDeferredCliValue(String(value), { label });
+}
+export function 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 });
+}
+export function stringArrayOption(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));
+}
+export function validateUnknownFlags(argv, allowedFlags, scope) {
+    for (const flag of Object.keys(argv)) {
+        if (!allowedFlags.has(flag)) {
+            throw new Error(`[${scope}] unknown option: --${flag}`);
+        }
+    }
+}
+export function validateNoPrefixedFlags(args, allowedFlags, scope) {
+    const flag = args.find((arg) => arg.startsWith('--no-') && !allowedFlags.has(arg));
+    if (flag) {
+        throw new Error(`[${scope}] unknown option: ${flag}`);
+    }
+}

package/dist/cli/parse/dev.d.ts

@@ -0,0 +1,17 @@
+import type { AukletEnvContext } from '#auklet/env';
+import type { BuildCommandOptions } from '#auklet/cli/parse/build';
+export type DevCommandOptions = BuildCommandOptions;
+export declare function parseDevCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    envContext: AukletEnvContext;
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+    };
+    overrides: import("../..").AukletConfig;
+    passthroughArgs: string[];
+    workspaceScriptArgs: string[];
+};

package/dist/cli/parse/dev.js

@@ -0,0 +1,4 @@
+import { parseBuildCommand } from '#auklet/cli/parse/build';
+export function parseDevCommand(args, options) {
+    return parseBuildCommand(args, options);
+}

package/dist/cli/parse/owner.d.ts

@@ -0,0 +1,11 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function parseOwnerCommand(args: Array<string>, options: {
+    cwd: string;
+    envContext: AukletEnvContext;
+}): {
+    cwd: string;
+    users: string[];
+    filters: string[];
+    packages: string[];
+    otp: string | undefined;
+};

package/dist/cli/parse/owner.js

@@ -0,0 +1,25 @@
+import minimist from 'minimist';
+import { stringArrayOption, stringOption, stripArgsSeparator, validateNoPrefixedFlags, validateUnknownFlags, } from '#auklet/cli/parse/core';
+const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
+export function parseOwnerCommand(args, options) {
+    const cliArgs = stripArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(), 'publish');
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'package', 'otp'],
+    });
+    validateUnknownFlags(argv, ownerFlags, 'publish');
+    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.');
+    }
+    return {
+        cwd: options.cwd,
+        users,
+        filters: stringArrayOption(argv.filter, '--filter', options.envContext),
+        packages: stringArrayOption(argv.package, '--package', options.envContext),
+        otp: stringOption(argv.otp, '--otp', options.envContext),
+    };
+}

package/dist/cli/parse/publish.d.ts

@@ -0,0 +1,19 @@
+import type { AukletEnvContext } from '#auklet/env';
+export declare function parsePublishCommand(args: Array<string>, options: {
+    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;
+};

package/dist/cli/parse/publish.js

@@ -0,0 +1,60 @@
+import minimist from 'minimist';
+import { booleanOption, deferredStringOption, dedupe, stringArrayOption, stringOption, stripArgsSeparator, validateNoPrefixedFlags, validateUnknownFlags, } from '#auklet/cli/parse/core';
+const publishFlags = new Set([
+    '_',
+    'filter',
+    'workspace',
+    'version',
+    'dry-run',
+    'format',
+    'git',
+    'otp',
+    'token',
+    'ignore-scripts',
+    'allow-dirty',
+]);
+export function parsePublishCommand(args, options) {
+    const argv = parsePublishArgs(args);
+    if (argv._.length) {
+        throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
+    }
+    return {
+        cwd: options.cwd,
+        otp: stringOption(argv.otp, '--otp', options.envContext),
+        filters: resolvePublishFilters(argv, options.envContext),
+        version: stringOption(argv.version, '--version', options.envContext),
+        git: booleanOption(argv.git, '--git', options.envContext, true),
+        format: booleanOption(argv.format, '--format', options.envContext, true),
+        dryRun: booleanOption(argv['dry-run'], '--dry-run', options.envContext),
+        allowDirty: booleanOption(argv['allow-dirty'], '--allow-dirty', options.envContext),
+        ignoreScripts: booleanOption(argv['ignore-scripts'], '--ignore-scripts', options.envContext),
+        token: deferredStringOption(argv.token, '--token'),
+    };
+}
+const parsePublishArgs = (args) => {
+    const cliArgs = stripArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']), 'publish');
+    const argv = minimist(cliArgs, {
+        string: [
+            'filter',
+            'version',
+            'otp',
+            'token',
+            'dry-run',
+            'format',
+            'git',
+            'ignore-scripts',
+            'allow-dirty',
+        ],
+        boolean: ['workspace'],
+    });
+    validateUnknownFlags(argv, publishFlags, 'publish');
+    return argv;
+};
+const resolvePublishFilters = (argv, envContext) => {
+    const filters = stringArrayOption(argv.filter, '--filter', envContext);
+    if (booleanOption(argv.workspace, '--workspace', envContext)) {
+        filters.push('*');
+    }
+    return dedupe(filters);
+};

package/dist/cli/parse/workspace.d.ts

@@ -0,0 +1,12 @@
+import type { AukletEnvContext } from '#auklet/env';
+export type WorkspaceSelection = {
+    filters: Array<string>;
+    includeDependencies: boolean;
+};
+export declare function parseWorkspaceSelectionArgs(args: Array<string>, envContext: AukletEnvContext): {
+    remainingArgs: string[];
+    workspace: {
+        filters: string[];
+        includeDependencies: boolean;
+    };
+};

package/dist/cli/parse/workspace.js

@@ -0,0 +1,45 @@
+import { resolveCliBoolean, resolveCliValue } from '#auklet/cli/parse/values';
+import { dedupe, readFlagValue, readOptionalFlagValue, } from '#auklet/cli/parse/core';
+export function parseWorkspaceSelectionArgs(args, envContext) {
+    const remainingArgs = [];
+    const filters = [];
+    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 value = readOptionalFlagValue(args, index, inlineValue);
+            includeDependencies =
+                value === undefined
+                    ? true
+                    : resolveCliBoolean(value, { label: name, context: envContext });
+            if (inlineValue === undefined && value !== undefined)
+                index += 1;
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    return {
+        remainingArgs,
+        workspace: {
+            filters: dedupe(filters),
+            includeDependencies,
+        },
+    };
+}

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>;