@karmaniverous/get-dotenv 4.2.0 → 4.2.2

package/dist/index.d.ts

@@ -4,18 +4,10 @@ import { Command } from '@commander-js/extra-typings';
  * Options passed programmatically to `getDotenvCli`.
  */
 interface GetDotenvCliOptions extends Omit<GetDotenvOptions, 'paths' | 'vars'> {
-    /**
-     * CLI alias. Should align with the `bin` property in `package.json`.
-     */
-    alias?: string;
     /**
      * Logs CLI internals when true.
      */
     debug?: boolean;
-    /**
-     * Cli description (appears in CLI help).
-     */
-    description?: string;
     /**
      * A delimited string of paths to dotenv files.
      */
@@ -30,6 +22,10 @@ interface GetDotenvCliOptions extends Omit<GetDotenvOptions, 'paths' | 'vars'> {
      * `pathsDelimiter`.
      */
     pathsDelimiterPattern?: string;
+    /**
+     * Shell scripts that can be executed from the CLI, either individually or via the batch subcommand.
+     */
+    shellScripts?: Record<string, string>;
     /**
      * A delimited string of key-value pairs declaratively specifying variables &
      * values to be loaded in addition to any dotenv files.
@@ -62,13 +58,9 @@ type GetDotenvDynamicFunction = (vars: ProcessEnv) => string | undefined;
 type GetDotenvDynamic = Record<string, GetDotenvDynamicFunction | ReturnType<GetDotenvDynamicFunction>>;
 type Logger = Record<string, (...args: unknown[]) => void> | typeof console;
 /**
- * Options passed programmatically to `getDotenv` and `getDotEnvSync`.
+ * Options passed programmatically to `getDotenv`.
  */
 interface GetDotenvOptions {
-    /**
-     * log internals to logger
-     */
-    debug?: boolean;
     /**
      * default target environment (used if `env` is not provided)
      */
@@ -76,7 +68,7 @@ interface GetDotenvOptions {
     /**
      * token indicating a dotenv file
      */
-    dotenvToken?: string;
+    dotenvToken: string;
     /**
      * path to JS module default-exporting an object keyed to dynamic variable functions
      */
@@ -129,10 +121,6 @@ interface GetDotenvOptions {
      * filename token indicating private variables
      */
     privateToken?: string;
-    /**
-     * Shell scripts that can be executed from the CLI, either individually or via the batch subcommand.
-     */
-    shellScripts?: Record<string, string>;
     /**
      * explicit variables to include
      */
@@ -190,11 +178,23 @@ type GetDotenvCliPostHookCallback = (dotenv: ProcessEnv) => Promise<void>;
  * sets defaults that can be overridden by local `getdotenv.config.json` in
  * projects that import the CLI.
  */
-interface GetDotenvCliGenerateOptions extends Omit<GetDotenvCliOptions, 'env'> {
+interface GetDotenvCliGenerateOptions extends GetDotenvCliOptions {
+    /**
+     * CLI alias. Should align with the `bin` property in `package.json`.
+     */
+    alias: string;
+    /**
+     * Cli description (appears in CLI help).
+     */
+    description: string;
+    /**
+     * The `import.meta.url` of the module generating the CLI.
+     */
+    importMetaUrl: string;
     /**
      * Logger object (defaults to console)
      */
-    logger?: Logger;
+    logger: Logger;
     /**
      * Mutates inbound options & executes side effects within the `getDotenv`
      * context before executing CLI commands.
@@ -210,7 +210,7 @@ interface GetDotenvCliGenerateOptions extends Omit<GetDotenvCliOptions, 'env'> {
 /**
  * Generate a Commander CLI Command for get-dotenv.
  */
-declare const generateGetDotenvCli: ({ logger, preHook, postHook, ...cliOptionsCustom }?: GetDotenvCliGenerateOptions) => Command;
+declare const generateGetDotenvCli: (customOptions: Pick<GetDotenvCliGenerateOptions, 'importMetaUrl'> & Partial<Omit<GetDotenvCliGenerateOptions, 'importMetaUrl'>>) => Promise<Command>;
 
 /**
  * Asynchronously process dotenv files of the form `.env[.<ENV>][.<PRIVATE_TOKEN>]`
@@ -218,6 +218,6 @@ declare const generateGetDotenvCli: ({ logger, preHook, postHook, ...cliOptionsC
  * @param options - `GetDotenvOptions` object
  * @returns The combined parsed dotenv object.
  */
-declare const getDotenv: (options?: GetDotenvOptions) => Promise<ProcessEnv>;
+declare const getDotenv: (options?: Partial<GetDotenvOptions>) => Promise<ProcessEnv>;
 
 export { type GetDotenvDynamic, type GetDotenvOptions, type ProcessEnv, dotenvExpand, dotenvExpandAll, dotenvExpandFromProcessEnv, generateGetDotenvCli, getDotenv };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import require$$0 from 'events';
 import require$$1 from 'child_process';
-import require$$0$1, { dirname, resolve } from 'path';
+import require$$0$1 from 'path';
 import require$$0$2 from 'fs';
 import require$$4$1 from 'process';
 import { Buffer as Buffer$1 } from 'node:buffer';
@@ -17,7 +17,7 @@ import require$$0$4 from 'constants';
 import require$$0$5 from 'util';
 import require$$5 from 'assert';
 import { webcrypto } from 'node:crypto';
-import url, { fileURLToPath as fileURLToPath$1 } from 'url';
+import url, { resolve, fileURLToPath as fileURLToPath$1 } from 'url';
 import fsPromises from 'node:fs/promises';
 import require$$2 from 'os';
 import require$$3 from 'crypto';
@@ -25700,115 +25700,27 @@ async function findUp(name, {
 	}
 }
 
-function findUpSync(name, {
-	cwd = process$3.cwd(),
-	type = 'file',
-	stopAt,
-} = {}) {
-	let directory = path$s.resolve(toPath$1(cwd) ?? '');
-	const {root} = path$s.parse(directory);
-	stopAt = path$s.resolve(directory, toPath$1(stopAt) ?? root);
-
-	while (directory && directory !== stopAt && directory !== root) {
-		const filePath = path$s.isAbsolute(name) ? name : path$s.join(directory, name);
-
-		try {
-			const stats = fs$v.statSync(filePath, {throwIfNoEntry: false});
-			if ((type === 'file' && stats?.isFile()) || (type === 'directory' && stats?.isDirectory())) {
-				return filePath;
-			}
-		} catch {}
-
-		directory = path$s.dirname(directory);
-	}
-}
-
 async function packageDirectory({cwd} = {}) {
 	const filePath = await findUp('package.json', {cwd});
 	return filePath && path$s.dirname(filePath);
 }
 
-function packageDirectorySync({cwd} = {}) {
-	const filePath = findUpSync('package.json', {cwd});
-	return filePath && path$s.dirname(filePath);
-}
-
-const __dirname = dirname(fileURLToPath$1(import.meta.url));
-/**
- * Absolute path to the global default CLI options file `getdotenv.config.json`.
- *
- * If `get-dotenv` is imported directly, this is the `getdotenv.config.json`
- * file at the root of the `get-dotenv` package.
- *
- * If `get-dotenv` has been used to generate a CLI which is in turn being
- * imported, this is the `getdotenv.config.json` file at the root of the
- * imported package.
- */
-const defaultGetDotenvCliOptionsGlobalPath = resolve(__dirname, '../getdotenv.config.json');
-/**
- * Global default CLI options.
- *
- * If `get-dotenv` is imported directly, these are derived from the
- * `getdotenv.config.json` file at the root of the `get-dotenv` package.
- *
- * If `get-dotenv` has been used to generate a CLI which is in turn being
- * imported, they are derived from the `getdotenv.config.json` file at the root
- * of the imported package.
- *
- * @defaultValue `{}`
- */
-const defaultGetDotenvCliOptionsGlobal = {
+const baseGetDotenvCliOptions = {
     dotenvToken: '.env',
     loadProcess: true,
+    logger: console,
     paths: './',
     pathsDelimiter: ' ',
     privateToken: 'local',
-    shellScripts: {},
+    shellScripts: {
+        'git-status': 'git branch --show-current && git status -s -u',
+    },
     vars: '',
     varsAssignor: '=',
     varsDelimiter: ' ',
-    ...(fs$a.existsSync(defaultGetDotenvCliOptionsGlobalPath)
-        ? JSON.parse(fs$a.readFileSync(defaultGetDotenvCliOptionsGlobalPath).toString())
-        : {}),
 };
-/**
- * Path to the nearest package directory.
- */
-const pkgDir = packageDirectorySync();
-if (!pkgDir)
-    throw new Error('Package directory not found.');
-/**
- * Absolute path to the local default CLI options file `getdotenv.config.json`.
- */
-const defaultGetDotenvCliOptionsLocalPath = resolve(pkgDir, 'getdotenv.config.json');
-/**
- * Local default CLI options.
- *
- * @defaultValue `{}`
- */
-const defaultGetDotenvCliOptionsLocal = (fs$a.existsSync(defaultGetDotenvCliOptionsLocalPath)
-    ? JSON.parse(fs$a.readFileSync(defaultGetDotenvCliOptionsLocalPath).toString())
-    : {});
 
-/**
- * Merges two sets of `getDotenv` options and eliminates any falsy `vars`. `target` takes precedence.
- *
- * @param target - Target options object (takes precedence).
- * @param source - Source options object (provides defaults).
- * @returns Merged options object.
- */
-const mergeGetDotenvOptions = (target = {}, source = {}) => ({
-    ...source,
-    ...target,
-    shellScripts: {
-        ...(source.shellScripts ?? {}),
-        ...(target.shellScripts ?? {}),
-    },
-    vars: _.pickBy({
-        ...(source.vars ?? {}),
-        ...(target.vars ?? {}),
-    }, (v) => !!v),
-});
+const getDotenvOptionsFilename = 'getdotenv.config.json';
 /**
  * Converts programmatic CLI options to `getDotenv` options.
  *
@@ -25816,8 +25728,8 @@ const mergeGetDotenvOptions = (target = {}, source = {}) => ({
  *
  * @returns `getDotenv` options.
  */
-const getDotenvCliOptions2Options = ({ paths, pathsDelimiter, pathsDelimiterPattern, vars, varsAssignor, varsAssignorPattern, varsDelimiter, varsDelimiterPattern, ...rest } = {}) => ({
-    ...rest,
+const getDotenvCliOptions2Options = ({ paths, pathsDelimiter, pathsDelimiterPattern, vars, varsAssignor, varsAssignorPattern, varsDelimiter, varsDelimiterPattern, ...rest }) => ({
+    ..._.omit(rest, ['debug', 'shellScripts']),
     paths: paths?.split(pathsDelimiterPattern
         ? RegExp(pathsDelimiterPattern)
         : pathsDelimiter ?? ' ') ?? [],
@@ -25829,18 +25741,20 @@ const getDotenvCliOptions2Options = ({ paths, pathsDelimiter, pathsDelimiterPatt
         ? RegExp(varsAssignorPattern)
         : varsAssignor ?? '='))),
 });
-/**
- * Extracts default programmatic `getDotenv` options from the global & local
- * CLI options defined in the respective `getdotenv.config.json` files.
- */
-const getDotenvDefaultOptions = getDotenvCliOptions2Options({
-    ...defaultGetDotenvCliOptionsGlobal,
-    ...defaultGetDotenvCliOptionsLocal,
-    shellScripts: {
-        ...(defaultGetDotenvCliOptionsGlobal.shellScripts ?? {}),
-        ...(defaultGetDotenvCliOptionsLocal.shellScripts ?? {}),
-    },
-});
+const resolveGetDotenvOptions = async (customOptions) => {
+    const localPkgDir = await packageDirectory();
+    const localOptionsPath = localPkgDir
+        ? resolve(localPkgDir, getDotenvOptionsFilename)
+        : undefined;
+    const localOptions = (localOptionsPath && (await fs$a.exists(localOptionsPath))
+        ? JSON.parse((await fs$a.readFile(localOptionsPath)).toString())
+        : {});
+    const result = _.defaultsDeep(customOptions, getDotenvCliOptions2Options(_.defaultsDeep(localOptions, baseGetDotenvCliOptions)));
+    return {
+        ...result,
+        vars: _.pickBy(result.vars ?? {}, (v) => !!v),
+    };
+};
 
 var main$1 = {exports: {}};
 
@@ -26310,7 +26224,7 @@ const readDotenv = async (path) => {
  */
 const getDotenv = async (options = {}) => {
     // Apply defaults.
-    const { defaultEnv, dotenvToken = '.env', dynamicPath, env, excludeDynamic = false, excludeEnv = false, excludeGlobal = false, excludePrivate = false, excludePublic = false, loadProcess = false, log = false, logger = console, outputPath, paths = [], privateToken = 'local', vars = {}, } = mergeGetDotenvOptions(options, getDotenvDefaultOptions);
+    const { defaultEnv, dotenvToken = '.env', dynamicPath, env, excludeDynamic = false, excludeEnv = false, excludeGlobal = false, excludePrivate = false, excludePublic = false, loadProcess = false, log = false, logger = console, outputPath, paths = [], privateToken = 'local', vars = {}, } = await resolveGetDotenvOptions(options);
     // Read .env files.
     const loaded = paths.length
         ? await paths.reduce(async (e, p) => {
@@ -34116,14 +34030,14 @@ const globPaths = async ({ globs, logger, pkgCwd, rootPath, }) => {
         cwd = pkgDir;
     }
     const absRootPath = require$$0$1.posix.join(cwd.split(require$$0$1.sep).join(require$$0$1.posix.sep), rootPath.split(require$$0$1.sep).join(require$$0$1.posix.sep));
-    const paths = await globby(globs, {
+    const paths = await globby(globs.split(/\s+/), {
         cwd: absRootPath,
         expandDirectories: false,
         onlyDirectories: true,
         absolute: true,
     });
     if (!paths.length) {
-        logger.error(`No paths found for globs '${globs.toString()}' at '${absRootPath}'.`);
+        logger.error(`No paths found for globs '${globs}' at '${absRootPath}'.`);
         process.exit(0);
     }
     return { absRootPath, paths };
@@ -34144,7 +34058,7 @@ const execShellCommandBatch = async ({ command, globs, ignoreErrors, list, logge
         : 'Executing shell command batch...';
     logger.info('');
     const headerRootPath = `ROOT:  ${absRootPath}`;
-    const headerGlobs = `GLOBS: ${globs.toString()}`;
+    const headerGlobs = `GLOBS: ${globs}`;
     const headerCommand = `CMD:   ${command}`;
     logger.info('*'.repeat(Math.max(headerTitle.length, headerRootPath.length, headerGlobs.length, headerCommand.length)));
     logger.info(headerTitle);
@@ -34191,7 +34105,7 @@ const cmdCommand$1 = new Command()
         throw new Error(`unable to resolve parent command`);
     if (!thisCommand.parent.parent)
         throw new Error(`unable to resolve root command`);
-    const { getDotenvOptions: { logger = console, shellScripts }, } = thisCommand.parent.parent;
+    const { getDotenvCliOptions: { logger = console, shellScripts }, } = thisCommand.parent.parent;
     const { ignoreErrors, globs, list, pkgCwd, rootPath } = thisCommand.parent.opts();
     // Execute shell command.
     {
@@ -34215,14 +34129,14 @@ const batchCommand = new Command()
     .passThroughOptions()
     .option('-p, --pkg-cwd', 'use nearest package directory as current working directory')
     .option('-r, --root-path <string>', 'path to batch root directory from current working directory', './')
-    .option('-g, --globs <strings...>', 'space-delimited globs from root path', '*')
+    .option('-g, --globs <string>', 'space-delimited globs from root path', '*')
     .option('-c, --command <string>', 'shell command string, conflicts with cmd subcommand (dotenv-expanded)', dotenvExpandFromProcessEnv)
     .option('-l, --list', 'list working directories without executing command')
     .option('-e, --ignore-errors', 'ignore errors and continue with next path')
     .hook('preSubcommand', async (thisCommand) => {
     if (!thisCommand.parent)
         throw new Error(`unable to resolve root command`);
-    const { getDotenvOptions: { logger = console, shellScripts }, } = thisCommand.parent;
+    const { getDotenvCliOptions: { logger = console, shellScripts }, } = thisCommand.parent;
     const { command, ignoreErrors, globs, list, pkgCwd, rootPath } = thisCommand.opts();
     if (command && thisCommand.args.length) {
         logger.error(`--command option conflicts with cmd subcommand.`);
@@ -34249,13 +34163,15 @@ const cmdCommand = new Command()
     .enablePositionalOptions()
     .passThroughOptions()
     .action(async (options, thisCommand) => {
+    if (thisCommand.args.length === 0)
+        return;
     if (!thisCommand.parent)
         throw new Error('parent command not found');
-    const { getDotenvOptions: { debug, logger = console, shellScripts }, } = thisCommand.parent;
+    const { getDotenvCliOptions: { debug, logger = console, shellScripts }, } = thisCommand.parent;
     const command = thisCommand.args.join(' ');
     const shellCommand = shellScripts?.[command] ?? command;
     if (debug)
-        logger.log('\n*** shell command ***\n', shellCommand);
+        logger.log('\n*** shell command ***\n', `'${shellCommand}'`);
     await execaCommand(shellCommand, {
         shell: true,
         stdio: 'inherit',
@@ -34263,19 +34179,50 @@ const cmdCommand = new Command()
 });
 
 /**
- * Generate a Commander CLI Command for get-dotenv.
+ * Resolve `GetDotenvCliGenerateOptions` from `import.meta.url` and custom options.
  */
-const generateGetDotenvCli = ({ logger = console, preHook, postHook, ...cliOptionsCustom } = {}) => {
-    const { alias = 'getdotenv', debug, defaultEnv, description = 'Base CLI.', dotenvToken, dynamicPath, env, excludeDynamic, excludeEnv, excludeGlobal, excludePrivate, excludePublic, loadProcess, log, outputPath, paths, pathsDelimiter, pathsDelimiterPattern, privateToken, shellScripts, varsAssignor, varsAssignorPattern, varsDelimiter, varsDelimiterPattern, } = {
-        ...defaultGetDotenvCliOptionsGlobal,
-        ...cliOptionsCustom,
-        ...defaultGetDotenvCliOptionsLocal,
-        shellScripts: {
-            ...(defaultGetDotenvCliOptionsGlobal.shellScripts ?? {}),
-            ...(cliOptionsCustom.shellScripts ?? {}),
-            ...(defaultGetDotenvCliOptionsLocal.shellScripts ?? {}),
-        },
+const resolveGetDotenvCliGenerateOptions = async ({ importMetaUrl, ...customOptions }) => {
+    const baseOptions = {
+        ...baseGetDotenvCliOptions,
+        alias: 'getdotenv',
+        description: 'Base CLI.',
     };
+    const globalPkgDir = importMetaUrl
+        ? await packageDirectory({
+            cwd: fileURLToPath$1(importMetaUrl),
+        })
+        : undefined;
+    const globalOptionsPath = globalPkgDir
+        ? resolve(globalPkgDir, getDotenvOptionsFilename)
+        : undefined;
+    const globalOptions = (globalOptionsPath && (await fs$a.exists(globalOptionsPath))
+        ? JSON.parse((await fs$a.readFile(globalOptionsPath)).toString())
+        : {});
+    const localPkgDir = await packageDirectory();
+    const localOptionsPath = localPkgDir
+        ? resolve(localPkgDir, getDotenvOptionsFilename)
+        : undefined;
+    const localOptions = (localOptionsPath &&
+        localOptionsPath !== globalOptionsPath &&
+        (await fs$a.exists(localOptionsPath))
+        ? JSON.parse((await fs$a.readFile(localOptionsPath)).toString())
+        : {});
+    return _.defaultsDeep(customOptions, localOptions, globalOptions, baseOptions);
+};
+
+const resolveExclusion = (exclude, excludeOff, defaultValue) => exclude ? true : excludeOff ? undefined : defaultValue ? true : undefined;
+const resolveExclusionAll = (exclude, excludeOff, defaultValue, excludeAll, excludeAllOff) => excludeAll && !excludeOff
+    ? true
+    : excludeAllOff && !exclude
+        ? undefined
+        : defaultValue
+            ? true
+            : undefined;
+/**
+ * Generate a Commander CLI Command for get-dotenv.
+ */
+const generateGetDotenvCli = async (customOptions) => {
+    const { alias, debug, defaultEnv, description, dotenvToken, dynamicPath, env, excludeDynamic, excludeEnv, excludeGlobal, excludePrivate, excludePublic, loadProcess, log, logger, outputPath, paths, pathsDelimiter, pathsDelimiterPattern, postHook, preHook, privateToken, shellScripts, varsAssignor, varsAssignorPattern, varsDelimiter, varsDelimiterPattern, } = await resolveGetDotenvCliGenerateOptions(customOptions);
     const excludeAll = !!excludeDynamic &&
         ((!!excludeEnv && !!excludeGlobal) ||
             (!!excludePrivate && !!excludePublic));
@@ -34328,67 +34275,50 @@ const generateGetDotenvCli = ({ logger = console, preHook, postHook, ...cliOptio
         .addCommand(batchCommand)
         .addCommand(cmdCommand, { isDefault: true })
         .hook('preSubcommand', async (thisCommand) => {
-        const rawOptions = thisCommand.opts();
-        if (rawOptions.debug)
-            logger.log('\n*** raw cli options ***\n', { rawOptions });
-        // Load options.
-        const { command, debugOff, excludeAll, excludeAllOff, excludeDynamicOff, excludeEnvOff, excludeGlobalOff, excludePrivateOff, excludePublicOff, loadProcessOff, logOff, ...cliOptions } = {
-            ...rawOptions,
-            shellScripts: rawOptions.shellScripts
-                ? JSON.parse(rawOptions.shellScripts)
-                : undefined,
-        };
+        // Get parent command GetDotenvCliOptions.
+        const parentGetDotenvCliOptions = process.env.getDotenvCliOptions
+            ? JSON.parse(process.env.getDotenvCliOptions)
+            : undefined;
+        // Get raw CLI options from commander.
+        const rawCliOptions = thisCommand.opts();
+        // Extract current GetDotenvCliOptions from raw CLI options.
+        const { command, debugOff, excludeAll, excludeAllOff, excludeDynamicOff, excludeEnvOff, excludeGlobalOff, excludePrivateOff, excludePublicOff, loadProcessOff, logOff, shellScripts, ...rawCliOptionsRest } = rawCliOptions;
+        const currentGetDotenvCliOptions = rawCliOptionsRest;
+        if (shellScripts)
+            currentGetDotenvCliOptions.shellScripts = JSON.parse(shellScripts);
+        // Merge current & parent GetDotenvCliOptions.
+        const mergedGetDotenvCliOptions = _.defaultsDeep(currentGetDotenvCliOptions, parentGetDotenvCliOptions ?? {});
         // Resolve flags.
-        const resolveExclusion = (exclude, excludeOff, defaultValue) => exclude
-            ? true
-            : excludeOff
-                ? undefined
-                : defaultValue
-                    ? true
-                    : undefined;
-        const resolveExclusionAll = (exclude, excludeOff, defaultValue) => excludeAll && !excludeOff
-            ? true
-            : excludeAllOff && !exclude
-                ? undefined
-                : defaultValue
-                    ? true
-                    : undefined;
-        cliOptions.debug = resolveExclusion(cliOptions.debug, debugOff, debug);
-        cliOptions.excludeDynamic = resolveExclusionAll(cliOptions.excludeDynamic, excludeDynamicOff, excludeDynamic);
-        cliOptions.excludeEnv = resolveExclusionAll(cliOptions.excludeEnv, excludeEnvOff, excludeEnv);
-        cliOptions.excludeGlobal = resolveExclusionAll(cliOptions.excludeGlobal, excludeGlobalOff, excludeGlobal);
-        cliOptions.excludePrivate = resolveExclusionAll(cliOptions.excludePrivate, excludePrivateOff, excludePrivate);
-        cliOptions.excludePublic = resolveExclusionAll(cliOptions.excludePublic, excludePublicOff, excludePublic);
-        cliOptions.log = resolveExclusion(cliOptions.log, logOff, log);
-        cliOptions.loadProcess = resolveExclusion(cliOptions.loadProcess, loadProcessOff, loadProcess);
-        if (cliOptions.debug)
-            logger.log('\n*** cli options after default resolution ***\n', {
-                cliOptions,
+        mergedGetDotenvCliOptions.debug = resolveExclusion(mergedGetDotenvCliOptions.debug, debugOff, debug);
+        mergedGetDotenvCliOptions.excludeDynamic = resolveExclusionAll(mergedGetDotenvCliOptions.excludeDynamic, excludeDynamicOff, excludeDynamic, excludeAll, excludeAllOff);
+        mergedGetDotenvCliOptions.excludeEnv = resolveExclusionAll(mergedGetDotenvCliOptions.excludeEnv, excludeEnvOff, excludeEnv, excludeAll, excludeAllOff);
+        mergedGetDotenvCliOptions.excludeGlobal = resolveExclusionAll(mergedGetDotenvCliOptions.excludeGlobal, excludeGlobalOff, excludeGlobal, excludeAll, excludeAllOff);
+        mergedGetDotenvCliOptions.excludePrivate = resolveExclusionAll(mergedGetDotenvCliOptions.excludePrivate, excludePrivateOff, excludePrivate, excludeAll, excludeAllOff);
+        mergedGetDotenvCliOptions.excludePublic = resolveExclusionAll(mergedGetDotenvCliOptions.excludePublic, excludePublicOff, excludePublic, excludeAll, excludeAllOff);
+        mergedGetDotenvCliOptions.log = resolveExclusion(mergedGetDotenvCliOptions.log, logOff, log);
+        mergedGetDotenvCliOptions.loadProcess = resolveExclusion(mergedGetDotenvCliOptions.loadProcess, loadProcessOff, loadProcess);
+        if (mergedGetDotenvCliOptions.debug && parentGetDotenvCliOptions)
+            logger.debug('\n*** parent command GetDotenvCliOptions ***\n', parentGetDotenvCliOptions);
+        if (mergedGetDotenvCliOptions.debug)
+            logger.debug('\n*** current command raw options ***\n', rawCliOptions);
+        if (mergedGetDotenvCliOptions.debug)
+            logger.debug('\n*** current command GetDotenvCliOptions ***\n', currentGetDotenvCliOptions);
+        if (mergedGetDotenvCliOptions.debug)
+            logger.debug('\n*** merged GetDotenvCliOptions ***\n', {
+                mergedGetDotenvCliOptions,
             });
         // Execute pre-hook.
         if (preHook) {
-            await preHook(cliOptions);
-            if (cliOptions.debug)
-                logger.log('\n*** cli options after pre-hook ***\n', cliOptions);
+            await preHook(mergedGetDotenvCliOptions);
+            if (mergedGetDotenvCliOptions.debug)
+                logger.debug('\n*** GetDotenvCliOptions after pre-hook ***\n', mergedGetDotenvCliOptions);
         }
-        // Get getdotenv options from parent command.
-        const parentGetdotenvOptions = (process.env.getDotenvOptions
-            ? JSON.parse(process.env.getDotenvOptions)
-            : {});
-        const cliGetDotenvOptions = getDotenvCliOptions2Options(cliOptions);
-        const getDotenvOptions = mergeGetDotenvOptions(cliGetDotenvOptions, parentGetdotenvOptions);
-        if (cliOptions.debug)
-            logger.log('\n*** getdotenv option resolution ***\n', {
-                parentGetdotenvOptions,
-                cliGetDotenvOptions,
-                getDotenvOptions,
-            });
+        // Persist GetDotenvCliOptions in command for subcommand access.
+        _.set(thisCommand, 'getDotenvCliOptions', mergedGetDotenvCliOptions);
         // Execute getdotenv.
-        const getDotenvOptionsProp = { ...getDotenvOptions, logger };
-        _.set(thisCommand, 'getDotenvOptions', getDotenvOptionsProp);
-        const dotenv = await getDotenv(getDotenvOptionsProp);
-        if (cliOptions.debug)
-            logger.log('\n*** resulting dotenv values ***\n', { dotenv });
+        const dotenv = await getDotenv(getDotenvCliOptions2Options(mergedGetDotenvCliOptions));
+        if (mergedGetDotenvCliOptions.debug)
+            logger.debug('\n*** getDotenv output ***\n', dotenv);
         // Execute post-hook.
         if (postHook)
             await postHook(dotenv);
@@ -34398,13 +34328,13 @@ const generateGetDotenvCli = ({ logger = console, preHook, postHook, ...cliOptio
             process.exit(0);
         }
         if (command) {
-            const shellCommand = getDotenvOptionsProp.shellScripts?.[command] ?? command;
-            if (cliOptions.debug)
-                logger.log('\n*** shell command ***\n', shellCommand);
+            const shellCommand = mergedGetDotenvCliOptions.shellScripts?.[command] ?? command;
+            if (mergedGetDotenvCliOptions.debug)
+                logger.debug('\n*** shell command ***\n', shellCommand);
             await execaCommand(shellCommand, {
                 env: {
                     ...process.env,
-                    getDotenvOptions: JSON.stringify(getDotenvOptions),
+                    getDotenvCliOptions: JSON.stringify(_.omit(mergedGetDotenvCliOptions, ['logger'])),
                 },
                 shell: true,
                 stdio: 'inherit',

package/package.json

@@ -131,5 +131,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "4.2.0"
+  "version": "4.2.2"
 }