auklet 0.1.2 → 0.1.4

package/README.md

@@ -163,8 +163,25 @@ package directory. Package-local `.npmrc` files and
 `package.json#publishConfig.registry` are respected.
 `--otp` is forwarded to `pnpm publish` for npm accounts or organizations that
 require publish 2FA, and to `pnpm owner add` for owner management 2FA.
-`--token` sets `NODE_AUTH_TOKEN` and `NPM_TOKEN` for publish subprocesses. The
-token still needs npmrc auth config, for example:
+Build and publish commands load `.env` and `.env.local` files by default. In
+monorepos, root env files are loaded before target package env files, and local
+env files override normal env files. Shell environment values keep the highest
+priority:
+
+1. `process.env`
+2. target package `.env.local`
+3. target package `.env`
+4. root `.env.local`
+5. root `.env`
+
+String CLI values can reference the loaded environment with `env:NAME`, for
+example `auk build --source env:AUKLET_SOURCE`. Boolean CLI values also support
+`env:NAME` when passed explicitly, for example
+`auk publish --dry-run=env:AUKLET_DRY_RUN`.
+`--token <value>` sets `NODE_AUTH_TOKEN` and `NPM_TOKEN` for publish
+subprocesses. Use `--token env:NODE_AUTH_TOKEN` to read the token from the
+loaded environment instead of putting the token value in the command.
+The token still needs npmrc auth config, for example:
 
 ```ini
 //registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}

package/dist/build/tsdown/dependencies.js

@@ -1,6 +1,6 @@
 import { parseModuleId } from 'conditional-export';
-import { createScopedAukletLogger } from '#auklet/logger';
-const logger = createScopedAukletLogger('build');
+import { createAukletLogger } from '#auklet/logger';
+const logger = createAukletLogger({ scope: 'build' });
 const getExternal = (names) => {
     const external = new Set();
     for (const name of names) {

package/dist/cli/build.js

@@ -4,27 +4,37 @@ import { runTsdown } from '#auklet/build/runTsdown';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { createBuildEnv, resolveBuildCliArgs } from '#auklet/cli/buildArgs';
 import { runBuildCss } from '#auklet/cli/buildCss';
+import { AukletEnvContext } from '#auklet/env';
 import { createAukletLogger } from '#auklet/logger';
 export async function runBuildJs(args, options = {}) {
-    const buildArgs = resolveBuildCliArgs(args);
-    const config = mergeAukletConfigOverrides(options.config ?? {}, buildArgs.config);
-    const logger = createAukletLogger();
-    return logger.group('Build JavaScript', async () => {
-        return runTsdown(buildArgs.args, {
-            cwd: process.cwd(),
-            env: createBuildEnv(config),
+    const envContext = new AukletEnvContext(process.cwd());
+    return envContext.run(async () => {
+        const buildArgs = resolveBuildCliArgs(args, envContext);
+        const config = mergeAukletConfigOverrides(options.config ?? {}, buildArgs.config);
+        const logger = createAukletLogger();
+        return logger.group('Build JavaScript', async () => {
+            return runTsdown(buildArgs.args, {
+                cwd: process.cwd(),
+                env: {
+                    ...envContext.values,
+                    ...createBuildEnv(config),
+                },
+            });
         });
     });
 }
 export async function runBuild(args) {
-    const buildArgs = resolveBuildCliArgs(args);
-    const aukletConfig = mergeAukletConfigOverrides(await loadAukletConfig(process.cwd()), buildArgs.config);
-    cleanAukletOutputByConfig(process.cwd(), aukletConfig);
-    const jsExitCode = await runBuildJs(buildArgs.args, {
-        config: buildArgs.config,
+    const envContext = new AukletEnvContext(process.cwd());
+    return envContext.run(async () => {
+        const buildArgs = resolveBuildCliArgs(args, envContext);
+        const aukletConfig = mergeAukletConfigOverrides(await loadAukletConfig(process.cwd()), buildArgs.config);
+        cleanAukletOutputByConfig(process.cwd(), aukletConfig);
+        const jsExitCode = await runBuildJs(buildArgs.args, {
+            config: buildArgs.config,
+        });
+        if (jsExitCode)
+            return jsExitCode;
+        createAukletLogger().newline();
+        return runBuildCss([], { aukletConfig });
     });
-    if (jsExitCode)
-        return jsExitCode;
-    createAukletLogger().newline();
-    return runBuildCss([], { aukletConfig });
 }

package/dist/cli/buildArgs.d.ts

@@ -1,5 +1,6 @@
+import { AukletEnvContext } from '#auklet/env';
 import type { AukletConfig } from '#auklet/types';
-export declare function resolveBuildCliArgs(args: Array<string>): {
+export declare function resolveBuildCliArgs(args: Array<string>, envContext?: AukletEnvContext): {
     args: string[];
     config: AukletConfig;
 };

package/dist/cli/buildArgs.js

@@ -1,30 +1,38 @@
 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';
 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) {
+export function resolveBuildCliArgs(args, envContext = new AukletEnvContext(process.cwd())) {
     const remainingArgs = [];
     const config = {};
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         const [name, inlineValue] = arg.split('=', 2);
         if (name === '--source') {
-            config.source = getFlagValue(args, index, inlineValue, name);
+            config.source = getResolvedFlagValue(args, index, inlineValue, name, envContext);
             if (inlineValue === undefined)
                 index += 1;
             continue;
         }
         if (name === '--output') {
-            config.output = getFlagValue(args, index, inlineValue, name);
+            config.output = getResolvedFlagValue(args, index, inlineValue, name, envContext);
             if (inlineValue === undefined)
                 index += 1;
             continue;
         }
         if (name === '--modules') {
-            config.modules = true;
+            const value = getOptionalFlagValue(args, index, inlineValue);
+            config.modules =
+                value === undefined
+                    ? true
+                    : resolveCliBoolean(value, { label: name, context: envContext });
+            if (inlineValue === undefined && value !== undefined)
+                index += 1;
             continue;
         }
         if (name === '--no-modules') {
@@ -34,7 +42,7 @@ export function resolveBuildCliArgs(args) {
         if (name === '--build.formats') {
             config.build = {
                 ...config.build,
-                formats: parseBuildFormats(getFlagValue(args, index, inlineValue, name)),
+                formats: parseBuildFormats(getResolvedFlagValue(args, index, inlineValue, name, envContext)),
             };
             if (inlineValue === undefined)
                 index += 1;
@@ -43,7 +51,7 @@ export function resolveBuildCliArgs(args) {
         if (name === '--build.target') {
             config.build = {
                 ...config.build,
-                target: getFlagValue(args, index, inlineValue, name),
+                target: getResolvedFlagValue(args, index, inlineValue, name, envContext),
             };
             if (inlineValue === undefined)
                 index += 1;
@@ -52,7 +60,7 @@ export function resolveBuildCliArgs(args) {
         if (name === '--build.platform') {
             config.build = {
                 ...config.build,
-                platform: parseBuildPlatform(getFlagValue(args, index, inlineValue, name)),
+                platform: parseBuildPlatform(getResolvedFlagValue(args, index, inlineValue, name, envContext)),
             };
             if (inlineValue === undefined)
                 index += 1;
@@ -61,7 +69,7 @@ export function resolveBuildCliArgs(args) {
         if (name === '--build.tsconfig') {
             config.build = {
                 ...config.build,
-                tsconfig: getFlagValue(args, index, inlineValue, name),
+                tsconfig: getResolvedFlagValue(args, index, inlineValue, name, envContext),
             };
             if (inlineValue === undefined)
                 index += 1;
@@ -91,6 +99,20 @@ const getFlagValue = (args, index, inlineValue, flag) => {
     }
     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), {
+        label: flag,
+        context: envContext,
+    });
+};
 const parseBuildFormats = (value) => {
     const formats = value
         .split(',')

package/dist/cli/buildCss.d.ts

@@ -1,7 +1,9 @@
+import { AukletEnvContext } from '#auklet/env';
 import { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
 import type { AukletConfig } from '#auklet/types';
 export declare function resolveBuildCssConfig(args: Array<string>, options?: {
     aukletConfig?: AukletConfig;
+    envContext?: AukletEnvContext;
 }): Promise<{
     aukletConfig: AukletConfig;
     shouldWatch: boolean;

package/dist/cli/buildCss.js

@@ -1,12 +1,13 @@
 import { createAukletLogger } from '#auklet/logger';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { AukletEnvContext } from '#auklet/env';
 import { ModuleStyleWatcher } from '#auklet/css/watch/watcher';
 import { ModuleStyleBuilder } from '#auklet/css/production/builder';
 import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
 import { logModuleStyleBuildResult } from '#auklet/css/production/buildReporter';
 export async function resolveBuildCssConfig(args, options = {}) {
-    const buildArgs = resolveBuildCliArgs(args);
+    const buildArgs = resolveBuildCliArgs(args, options.envContext);
     const shouldWatch = buildArgs.args.includes('--watch') || buildArgs.args.includes('-w');
     const aukletConfig = options.aukletConfig ??
         mergeAukletConfigOverrides(await loadAukletConfig(process.cwd(), {
@@ -28,26 +29,32 @@ export async function startBuildCssWatch(aukletConfig) {
     });
 }
 export async function runBuildCss(args, options = {}) {
-    const logger = createAukletLogger();
-    const { aukletConfig, shouldWatch } = await resolveBuildCssConfig(args, options);
-    if (shouldWatch) {
-        const watcher = await startBuildCssWatch(aukletConfig);
-        const close = () => {
-            watcher
-                .close()
-                .catch(console.error)
-                .finally(() => process.exit(0));
-        };
-        process.once('SIGINT', close);
-        process.once('SIGTERM', close);
-        await new Promise(() => { });
+    const envContext = new AukletEnvContext(process.cwd());
+    return envContext.run(async () => {
+        const logger = createAukletLogger();
+        const { aukletConfig, shouldWatch } = await resolveBuildCssConfig(args, {
+            ...options,
+            envContext,
+        });
+        if (shouldWatch) {
+            const watcher = await startBuildCssWatch(aukletConfig);
+            const close = () => {
+                watcher
+                    .close()
+                    .catch(console.error)
+                    .finally(() => process.exit(0));
+            };
+            process.once('SIGINT', close);
+            process.once('SIGTERM', close);
+            await new Promise(() => { });
+            return 0;
+        }
+        const builder = new ModuleStyleBuilder({ aukletConfig });
+        await logger.group('Build CSS', async () => {
+            const timer = logger.timer();
+            const result = await builder.build();
+            logModuleStyleBuildResult(logger.child('css'), result, timer.elapsed());
+        });
         return 0;
-    }
-    const builder = new ModuleStyleBuilder({ aukletConfig });
-    await logger.group('Build CSS', async () => {
-        const timer = logger.timer();
-        const result = await builder.build();
-        logModuleStyleBuildResult(logger.child('css'), result, timer.elapsed());
     });
-    return 0;
 }

package/dist/cli/dev.js

@@ -1,12 +1,19 @@
 import { execa } from 'execa';
 import { createTsdownArgs } from '#auklet/build/runTsdown';
 import { createBuildEnv, resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { AukletEnvContext } from '#auklet/env';
 import { resolveBuildCssConfig, startBuildCssWatch, } from '#auklet/cli/buildCss';
 export async function runDev(args) {
+    const envContext = new AukletEnvContext(process.cwd());
+    return envContext.run(async () => runDevWithEnv(args, envContext));
+}
+const runDevWithEnv = async (args, envContext) => {
     let closed = false;
     let jsProcess = null;
-    const buildArgs = resolveBuildCliArgs(args);
-    const { aukletConfig } = await resolveBuildCssConfig(['--watch', ...args]);
+    const buildArgs = resolveBuildCliArgs(args, envContext);
+    const { aukletConfig } = await resolveBuildCssConfig(['--watch', ...args], {
+        envContext,
+    });
     const cssWatcher = await startBuildCssWatch(aukletConfig);
     const close = async () => {
         if (closed)
@@ -23,7 +30,10 @@ export async function runDev(args) {
     try {
         jsProcess = execa(process.execPath, createTsdownArgs([...buildArgs.args, '--watch']), {
             cwd: process.cwd(),
-            env: createBuildEnv(buildArgs.config),
+            env: {
+                ...envContext.values,
+                ...createBuildEnv(buildArgs.config),
+            },
             stdio: 'inherit',
             reject: false,
         });
@@ -36,4 +46,4 @@ export async function runDev(args) {
         process.off('SIGTERM', closeAndExit);
         await close();
     }
-}
+};

package/dist/cli/values.d.ts

@@ -0,0 +1,17 @@
+import type { AukletEnvContext } from '#auklet/env';
+export type CliValueOptions = {
+    label: string;
+    context: AukletEnvContext;
+};
+export type DeferredCliValue = {
+    raw: string;
+    resolve(context: AukletEnvContext): string | undefined;
+};
+export declare function createDeferredCliValue(value: string, options: {
+    label: string;
+}): {
+    raw: string;
+    resolve(context: AukletEnvContext): string | undefined;
+};
+export declare function resolveCliValue(value: string | undefined, options: CliValueOptions): string | undefined;
+export declare function resolveCliBoolean(value: boolean | string | undefined, options: CliValueOptions): boolean;

package/dist/cli/values.js

@@ -0,0 +1,14 @@
+export function createDeferredCliValue(value, options) {
+    return {
+        raw: value,
+        resolve(context) {
+            return resolveCliValue(value, { label: options.label, context });
+        },
+    };
+}
+export function resolveCliValue(value, options) {
+    return options.context.resolveValue(value, { label: options.label });
+}
+export function resolveCliBoolean(value, options) {
+    return options.context.resolveBoolean(value, { label: options.label });
+}

package/dist/css/core/style/dependencies.d.ts

@@ -1,6 +1,5 @@
 import type { NormalizedAukletConfig } from '#auklet/types';
 export declare function getGlobalStyleDependencies(config: NormalizedAukletConfig): string[];
-export declare function getExternalStyleDependencies(config: NormalizedAukletConfig): string[];
 export declare function getThemeStyleDependencies(config: NormalizedAukletConfig, themeName: string): string[];
 export declare function getThemeNames(config: NormalizedAukletConfig): string[];
 export declare function getThemeStyleEntries(config: NormalizedAukletConfig): {

package/dist/css/core/style/dependencies.js

@@ -15,9 +15,6 @@ export function getGlobalStyleDependencies(config) {
     }
     return dependencies;
 }
-export function getExternalStyleDependencies(config) {
-    return getGlobalStyleDependencies(config);
-}
 export function getThemeStyleDependencies(config, themeName) {
     const dependencies = [];
     for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {

package/dist/css/core/style/entries.js

@@ -1,4 +1,4 @@
-import { getExternalStyleDependencies, getGlobalStyleDependencies, getThemeNames, getThemeStyleDependencies, } from '#auklet/css/core/style/dependencies';
+import { getGlobalStyleDependencies, getThemeNames, getThemeStyleDependencies, } from '#auklet/css/core/style/dependencies';
 import { StyleModuleEntryPlanner } from '#auklet/css/core/styleModuleEntryPlanner';
 const dependenciesPart = (specifiers) => ({ type: 'dependencies', specifiers });
 // 环境无关的 style entry graph。production writer 和 Vite/dev renderer 都从这里取入口语义。
@@ -21,7 +21,7 @@ export function createThemeEntryParts(config, themeName, options = {}) {
 }
 export function createExternalEntryParts(config) {
     return [
-        dependenciesPart(getExternalStyleDependencies(config)),
+        dependenciesPart(getGlobalStyleDependencies(config)),
     ];
 }
 export function collectModuleStyleImports(packageContext) {

package/dist/css/core/style/files.d.ts

@@ -1,3 +1,2 @@
 export declare function groupStyleFilesByDir(sourceRoot: string, styleFiles: Array<string>): Map<string, string[]>;
 export declare function createStyleFileKeySet(styleFiles: Iterable<string>): Set<string>;
-export declare function createStyleFileKey(styleFile: string): string;

package/dist/css/core/style/files.js

@@ -14,6 +14,3 @@ export function groupStyleFilesByDir(sourceRoot, styleFiles) {
 export function createStyleFileKeySet(styleFiles) {
     return new Set(Array.from(styleFiles, normalizeFileKey));
 }
-export function createStyleFileKey(styleFile) {
-    return normalizeFileKey(styleFile);
-}

package/dist/css/core/stylePackageContext.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
 import { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
-import { createStyleFileKey, createStyleFileKeySet, } from '#auklet/css/core/style/files';
+import { createStyleFileKeySet } from '#auklet/css/core/style/files';
 import { getThemeNames, resolveThemeStyleFiles, } from '#auklet/css/core/style/dependencies';
-import { fileWalker } from '#auklet/utils';
+import { fileWalker, normalizeFileKey } from '#auklet/utils';
 export class StylePackageContext {
     options;
     normalizedConfig;
@@ -36,6 +36,6 @@ export class StylePackageContext {
         const themeFileKeys = createStyleFileKeySet(this.themeFiles.values());
         return files
             .filter((file) => this.options.config.styleExtensions.includes(path.extname(file)))
-            .filter((styleFile) => !themeFileKeys.has(createStyleFileKey(styleFile)));
+            .filter((styleFile) => !themeFileKeys.has(normalizeFileKey(styleFile)));
     }
 }

package/dist/css/vite/hmr.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import { isString } from 'aidly';
 import { normalizeFileKey } from '#auklet/utils';
-import { createScopedAukletLogger } from '#auklet/logger';
+import { createAukletLogger } from '#auklet/logger';
 const FULL_RELOAD_SUPPRESS_MS = 100;
 const DUPLICATE_UPDATE_IGNORE_MS = 500;
-const logger = createScopedAukletLogger('css:vite');
+const logger = createAukletLogger({ scope: 'css:vite' });
 const toBrowserVirtualPath = (id) => {
     return `/@id/${id.replace('\0', '__x00__')}`;
 };

package/dist/css/vite/moduleGraph/packageSource/monorepo.d.ts

@@ -1,4 +1,4 @@
-import type { WorkspacePackageInfo } from '#auklet/workspace/packages';
+import { type WorkspacePackageInfo } from '#auklet/workspace/packages';
 import type { StylePackageInfo, StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
 export type MonorepoPackageSourceOptions = {
     root: string;

package/dist/css/vite/moduleGraph/packageSource/monorepo.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
+import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 import { normalizeFileKey, toPosixPath, toWatchPath } from '#auklet/utils';
-import { readPnpmWorkspacePackageInfoSync } from '#auklet/workspace/packages';
+import { readPnpmWorkspacePackageInfoSync, } from '#auklet/workspace/packages';
 export class MonorepoPackageSource {
     options;
     packages;

package/dist/env.d.ts

@@ -0,0 +1,22 @@
+export declare class AukletEnvContext {
+    private readonly packageRoot;
+    private readonly root?;
+    private readonly env;
+    private readonly processEnv;
+    constructor(packageRoot: string, root?: string | undefined, options?: {
+        processEnv?: Record<string, string | undefined>;
+    });
+    get values(): Record<string, string | undefined>;
+    get normalizedValues(): Record<string, string | undefined> | undefined;
+    createPackageContext(packageRoot: string): AukletEnvContext;
+    resolveValue(value: string | undefined, options: {
+        label: string;
+    }): string | undefined;
+    resolveBoolean(value: boolean | string | undefined, options: {
+        label: string;
+    }): boolean;
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    private readEnv;
+    private findEnvFiles;
+    private createProcessEnvOverrides;
+}

package/dist/env.js

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseEnv } from 'node:util';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
+const envFileNames = ['.env', '.env.local'];
+export class AukletEnvContext {
+    packageRoot;
+    root;
+    env;
+    processEnv;
+    constructor(packageRoot, root, options = {}) {
+        this.packageRoot = packageRoot;
+        this.root = root;
+        this.processEnv = { ...(options.processEnv ?? process.env) };
+        this.env = this.createProcessEnvOverrides(this.readEnv());
+    }
+    get values() {
+        return this.env;
+    }
+    get normalizedValues() {
+        return Object.keys(this.values).length ? this.values : undefined;
+    }
+    createPackageContext(packageRoot) {
+        return new AukletEnvContext(packageRoot, this.root, {
+            processEnv: this.processEnv,
+        });
+    }
+    resolveValue(value, options) {
+        if (!value)
+            return undefined;
+        if (!value.startsWith('env:'))
+            return value;
+        const name = value.slice('env:'.length);
+        if (!name) {
+            throw new Error(`${options.label} env: requires an environment name.`);
+        }
+        const resolved = this.processEnv[name] ?? this.values[name];
+        if (!resolved) {
+            throw new Error(`${options.label} environment is missing: ${name}`);
+        }
+        return resolved;
+    }
+    resolveBoolean(value, options) {
+        if (value === undefined)
+            return false;
+        if (typeof value === 'boolean')
+            return value;
+        if (!value)
+            return true;
+        const resolved = this.resolveValue(value, options);
+        if (resolved === undefined || !resolved)
+            return true;
+        const normalized = resolved.toLowerCase();
+        if (['1', 'true', 'yes', 'on'].includes(normalized))
+            return true;
+        if (['0', 'false', 'no', 'off'].includes(normalized))
+            return false;
+        throw new Error(`${options.label} requires a boolean value.`);
+    }
+    async run(fn) {
+        const originalEnv = { ...process.env };
+        for (const [key, value] of Object.entries(this.values)) {
+            if (originalEnv[key] === undefined && value !== undefined) {
+                process.env[key] = value;
+            }
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            process.env = originalEnv;
+        }
+    }
+    readEnv() {
+        const env = {};
+        for (const file of this.findEnvFiles()) {
+            Object.assign(env, parseEnv(fs.readFileSync(file, 'utf8')));
+        }
+        return env;
+    }
+    findEnvFiles() {
+        const files = [];
+        const packageDir = path.resolve(this.packageRoot);
+        const rootDir = path.resolve(this.root ?? findWorkspaceRoot(packageDir) ?? packageDir);
+        // Files are read in order and later files override earlier ones.
+        // Final priority is process.env > package .env.local > package .env >
+        // root .env.local > root .env.
+        const rootEnvFiles = envFileNames.map((fileName) => path.join(rootDir, fileName));
+        const packageEnvFiles = envFileNames.map((fileName) => path.join(packageDir, fileName));
+        for (const file of rootEnvFiles) {
+            if (fs.existsSync(file)) {
+                files.push(file);
+            }
+        }
+        for (const file of packageEnvFiles) {
+            if (!files.includes(file) && fs.existsSync(file)) {
+                files.push(file);
+            }
+        }
+        return files;
+    }
+    createProcessEnvOverrides(env) {
+        return Object.fromEntries(Object.entries(env).filter(([key]) => this.processEnv[key] === undefined));
+    }
+}

package/dist/logger.d.ts

@@ -2,4 +2,3 @@ import { Logger, type LoggerOptions } from 'briefing';
 export type AukletLogger = Logger;
 export type CreateAukletLoggerOptions = Pick<LoggerOptions, 'scope' | 'prefix' | 'colors' | 'silent' | 'verbose' | 'sink'>;
 export declare function createAukletLogger(options?: CreateAukletLoggerOptions): Logger;
-export declare function createScopedAukletLogger(scope: string): Logger;

package/dist/logger.js

@@ -9,6 +9,3 @@ export function createAukletLogger(options = {}) {
         sink: options.sink,
     });
 }
-export function createScopedAukletLogger(scope) {
-    return createAukletLogger({ scope });
-}

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

@@ -1,4 +1,8 @@
+export type NpmrcAuthEnvOptions = {
+    env?: Record<string, string | undefined>;
+};
 export declare function findNpmrcWithAuthToken(packageRoot: string, root: string, registry?: string): string | undefined;
 export declare function findNpmrcFiles(packageRoot: string, root: string): string[];
+export declare function validateNpmrcAuthEnv(packageRoot: string, root: string, options?: NpmrcAuthEnvOptions): void;
 export declare function hasAuthToken(content: string, registry?: string): boolean;
 export declare function toNpmrcRegistryKey(registry: string): string;