@vltpkg/cli-sdk 0.0.0-10

package/dist/esm/config/index.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Module that handles all vlt configuration needs
+ *
+ * Project-level configs are set in a `vlt.json` file in the local project
+ * if present. This will override the user-level configs in the appropriate
+ * XDG config path.
+ *
+ * Command-specific configuration can be specified by putting options in a
+ * field in the `command` object. For example:
+ *
+ * ```json
+ * {
+ *   "registry": "https://registry.npmjs.org/",
+ *   "command": {
+ *     "publish": {
+ *       "registry": "http://registry.internal"
+ *     }
+ *   }
+ * }
+ * ```
+ * @module
+ */
+import { PackageInfoClient } from '@vltpkg/package-info';
+import { PackageJson } from '@vltpkg/package-json';
+import { Monorepo } from '@vltpkg/workspaces';
+import type { Jack, OptionsResults, Unwrap } from 'jackspeak';
+import { PathScurry } from 'path-scurry';
+import { kIndent, kNewline } from 'polite-json';
+import type { Commands, RecordField } from './definition.ts';
+import { commands, definition, isRecordField, recordFields } from './definition.ts';
+export { commands, definition, isRecordField, recordFields, type Commands, };
+export declare const kCustomInspect: unique symbol;
+export type RecordPairs = Record<string, unknown>;
+export type RecordString = Record<string, string>;
+export type ConfigFiles = Record<string, ConfigFileData>;
+export type PairsAsRecords = Omit<ConfigOptions, 'projectRoot' | 'scurry' | 'packageJson' | 'monorepo' | 'packageInfo'> & {
+    command?: Record<string, ConfigOptions>;
+};
+export declare const pairsToRecords: (obj: ConfigFileData) => PairsAsRecords;
+export declare const recordsToPairs: (obj: RecordPairs) => RecordPairs;
+/**
+ * Config data can be any options, and also a 'command' field which
+ * contains command names and override options for that command.
+ */
+export type ConfigData = OptionsResults<ConfigDefinitions> & {
+    command?: Record<string, OptionsResults<ConfigDefinitions>>;
+};
+/**
+ * Config data as it appears in config files, with kv pair lists
+ * stored as `Record<string, string>`.
+ */
+export type ConfigFileData = {
+    [k in keyof ConfigData]?: k extends OptListKeys<ConfigData> ? RecordString | string[] : k extends 'command' ? ConfigFiles : ConfigData[k];
+};
+export type ConfigOptions = {
+    [k in keyof ConfigData]: k extends RecordField ? RecordString : k extends 'command' ? never : ConfigData[k];
+} & {
+    packageJson: PackageJson;
+    scurry: PathScurry;
+    projectRoot: string;
+    monorepo?: Monorepo;
+    packageInfo: PackageInfoClient;
+};
+/**
+ * The base config definition set as a type
+ */
+export type ConfigDefinitions = Unwrap<typeof definition>;
+export type StringListKeys<O> = {
+    [k in keyof O]: O[k] extends string[] | undefined ? k : never;
+};
+export type OptListKeys<O> = Exclude<StringListKeys<O>[keyof StringListKeys<O>], undefined>;
+/**
+ * Class that handles configuration for vlt.
+ *
+ * Call {@link Config.load} to get one of these.
+ */
+export declare class Config {
+    #private;
+    /**
+     * The {@link https://npmjs.com/jackspeak | JackSpeak} object
+     * representing vlt's configuration
+     */
+    jack: Jack<ConfigDefinitions>;
+    stringifyOptions: {
+        [kIndent]: string;
+        [kNewline]: string;
+    };
+    configFiles: ConfigFiles;
+    /**
+     * Parsed values in effect
+     */
+    values?: OptionsResults<ConfigDefinitions>;
+    /**
+     * Command-specific config values
+     */
+    commandValues: {
+        [cmd in Commands[keyof Commands]]?: ConfigData;
+    };
+    /**
+     * A flattened object of the parsed configuration
+     */
+    get options(): ConfigOptions;
+    /**
+     * Reset the options value, optionally setting a new project root
+     * to recalculate the options.
+     */
+    resetOptions(projectRoot?: string): void;
+    /**
+     * positional arguments to the vlt process
+     */
+    positionals?: string[];
+    /**
+     * The root of the project where a vlt.json, vlt-workspaces.json,
+     * package.json, or .git was found. Not necessarily the `process.cwd()`,
+     * though that is the default location.
+     *
+     * Never walks up as far as `$HOME`. So for example, if a project is in
+     * `~/projects/xyz`, then the highest dir it will check is `~/projects`
+     */
+    projectRoot: string;
+    /**
+     * `Record<alias, canonical name>` to dereference command aliases.
+     */
+    commands: Commands;
+    /**
+     * Which command name to use for overriding with command-specific values,
+     * determined from the argv when parse() is called.
+     */
+    command?: Commands[keyof Commands];
+    constructor(jack?: Jack<ConfigDefinitions>, projectRoot?: string);
+    /**
+     * Parse the arguments and set configuration and positionals accordingly.
+     */
+    parse(args?: string[]): this & ParsedConfig;
+    /**
+     * Get a `key=value` list option value as an object.
+     *
+     * For example, a list option with a vlaue of `['key=value', 'xyz=as=df' ]`
+     * would be returned as `{key: 'value', xyz: 'as=df'}`
+     *
+     * Results are memoized, so subsequent calls for the same key will return the
+     * same object. If new strings are added to the list, then the memoized value
+     * is *not* updated, so only use once configurations have been fully loaded.
+     *
+     * If the config value is not set at all, an empty object is returned.
+     */
+    getRecord(k: OptListKeys<ConfigData>): RecordString;
+    /**
+     * Get a configuration value.
+     *
+     * Note: `key=value` pair configs are returned as a string array. To get them
+     * as an object, use {@link Config#getRecord}.
+     */
+    get<K extends keyof OptionsResults<ConfigDefinitions>>(k: K): OptionsResults<ConfigDefinitions>[K];
+    /**
+     * Write the config values to the user or project config file.
+     */
+    writeConfigFile(which: 'project' | 'user', values: ConfigFileData): Promise<ConfigFileData>;
+    /**
+     * Fold in the provided fields with the existing properties
+     * in the config file.
+     */
+    addConfigToFile(which: 'project' | 'user', values: ConfigFileData): Promise<ConfigFileData>;
+    getFilename(which?: 'project' | 'user'): string;
+    deleteConfigKeys(which: 'project' | 'user', fields: string[]): Promise<boolean>;
+    /**
+     * Edit the user or project configuration file.
+     *
+     * If the file isn't present, then it starts with `{}` so the user has
+     * something to work with.
+     *
+     * If the result is not valid, or no config settings are contained in the
+     * file after editing, then it's restored to what it was before, which might
+     * mean deleting the file.
+     */
+    editConfigFile(which: 'project' | 'user', edit: (file: string) => Promise<void> | void): Promise<void>;
+    /**
+     * Find the local config file and load both it and the user-level config in
+     * the XDG config home.
+     *
+     * Note: if working in a workspaces monorepo, then the vlt.json file MUST
+     * be in the same folder as the vlt-workspaces.json file, because we stop
+     * looking when we find either one.
+     */
+    loadConfigFile(): Promise<this>;
+    /**
+     * Load the configuration and return a Promise to a
+     * {@link Config} object
+     */
+    static load(projectRoot?: string, argv?: string[], 
+    /**
+     * only used in tests, resets the memoization
+     * @internal
+     */
+    reload?: boolean): Promise<LoadedConfig>;
+}
+export type ParsedConfig = Config & {
+    command: NonNullable<Config['command']>;
+    values: OptionsResults<ConfigDefinitions>;
+    positionals: string[];
+};
+/**
+ * A fully loaded {@link Config} object
+ */
+export type LoadedConfig = ParsedConfig;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAE7C,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAK7D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC,OAAO,EAGL,OAAO,EACP,QAAQ,EACT,MAAM,aAAa,CAAA;AAEpB,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,EACL,QAAQ,EACR,UAAU,EAEV,aAAa,EACb,YAAY,EACb,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,QAAQ,EACR,UAAU,EACV,aAAa,EACb,YAAY,EACZ,KAAK,QAAQ,GACd,CAAA;AAED,eAAO,MAAM,cAAc,eAA2C,CAAA;AAEtE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AACjD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAwBxD,MAAM,MAAM,cAAc,GAAG,IAAI,CAC/B,aAAa,EACX,aAAa,GACb,QAAQ,GACR,aAAa,GACb,UAAU,GACV,aAAa,CAChB,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,cAAc,QACpB,cAAc,KAClB,cAgBF,CAAA;AAED,eAAO,MAAM,cAAc,QAAS,WAAW,KAAG,WA2BjD,CAAA;AAYD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC,iBAAiB,CAAC,GAAG;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC,CAAA;CAC5D,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;KAC1B,CAAC,IAAI,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,CAAC,UAAU,CAAC,GACzD,YAAY,GAAG,MAAM,EAAE,GACvB,CAAC,SAAS,SAAS,GAAG,WAAW,GACjC,UAAU,CAAC,CAAC,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;KACzB,CAAC,IAAI,MAAM,UAAU,GAAG,CAAC,SAAS,WAAW,GAAG,YAAY,GAC3D,CAAC,SAAS,SAAS,GAAG,KAAK,GAC3B,UAAU,CAAC,CAAC,CAAC;CAChB,GAAG;IACF,WAAW,EAAE,WAAW,CAAA;IACxB,MAAM,EAAE,UAAU,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,WAAW,EAAE,iBAAiB,CAAA;CAC/B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAEzD,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,SAAS,GAAG,CAAC,GAAG,KAAK;CAC9D,CAAA;AACD,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,OAAO,CAClC,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,cAAc,CAAC,CAAC,CAAC,CAAC,EAC1C,SAAS,CACV,CAAA;AAED;;;;GAIG;AACH,qBAAa,MAAM;;IACjB;;;OAGG;IACH,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAA;IAE7B,gBAAgB,EAAE;QAChB,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;QACjB,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KACnB,CAAwC;IAEzC,WAAW,EAAE,WAAW,CAAK;IAE7B;;OAEG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAA;IAE1C;;OAEG;IACH,aAAa,EAAE;SACZ,GAAG,IAAI,QAAQ,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC,EAAE,UAAU;KAC/C,CAAK;IAEN;;OAEG;IACH,IAAI,OAAO,IAAI,aAAa,CAiC3B;IAED;;;OAGG;IACH,YAAY,CAAC,WAAW,GAAE,MAAsB;IAQhD;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IAEtB;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAA;IAElB;;;OAGG;IACH,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,QAAQ,CAAC,CAAA;gBAGhC,IAAI,GAAE,IAAI,CAAC,iBAAiB,CAAc,EAC1C,WAAW,SAAgB;IAO7B;;OAEG;IACH,KAAK,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,IAAI,GAAG,YAAY;IAgCzD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,YAAY;IAkBnD;;;;;OAKG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,cAAc,CAAC,iBAAiB,CAAC,EACnD,CAAC,EAAE,CAAC,GACH,cAAc,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAKvC;;OAEG;IACG,eAAe,CACnB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,MAAM,EAAE,cAAc;IAaxB;;;OAGG;IACG,eAAe,CACnB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,MAAM,EAAE,cAAc;IAoExB,WAAW,CAAC,KAAK,GAAE,SAAS,GAAG,MAAkB,GAAG,MAAM;IAMpD,gBAAgB,CACpB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,MAAM,EAAE,MAAM,EAAE;IAiDlB;;;;;;;;;OASG;IACG,cAAc,CAClB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAqC9C;;;;;;;OAOG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAgDrC;;;OAGG;WACU,IAAI,CACf,WAAW,SAAgB,EAC3B,IAAI,WAAe;IACnB;;;OAGG;IACH,MAAM,UAAQ,GACb,OAAO,CAAC,YAAY,CAAC;CAOzB;AAKD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAClC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAA;IACvC,MAAM,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAA;IACzC,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,CAAA"}

package/dist/esm/config/index.js

@@ -0,0 +1,489 @@
+/**
+ * Module that handles all vlt configuration needs
+ *
+ * Project-level configs are set in a `vlt.json` file in the local project
+ * if present. This will override the user-level configs in the appropriate
+ * XDG config path.
+ *
+ * Command-specific configuration can be specified by putting options in a
+ * field in the `command` object. For example:
+ *
+ * ```json
+ * {
+ *   "registry": "https://registry.npmjs.org/",
+ *   "command": {
+ *     "publish": {
+ *       "registry": "http://registry.internal"
+ *     }
+ *   }
+ * }
+ * ```
+ * @module
+ */
+import { error } from '@vltpkg/error-cause';
+import { PackageInfoClient } from '@vltpkg/package-info';
+import { PackageJson } from '@vltpkg/package-json';
+import { Monorepo } from '@vltpkg/workspaces';
+import { XDG } from '@vltpkg/xdg';
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { lstat, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { PathScurry } from 'path-scurry';
+import { parse as jsonParse, stringify as jsonStringify, kIndent, kNewline, } from 'polite-json';
+import { walkUp } from 'walk-up-path';
+import { commands, definition, getCommand, isRecordField, recordFields, } from "./definition.js";
+import { merge } from "./merge.js";
+export { commands, definition, isRecordField, recordFields, };
+export const kCustomInspect = Symbol.for('nodejs.util.inspect.custom');
+// turn a set of pairs into a Record object.
+// if a kv pair doesn't have a = character, set to `''`
+const reducePairs = (pairs) => {
+    const record = {};
+    for (const kv of pairs) {
+        const eq = kv.indexOf('=');
+        if (eq === -1)
+            record[kv] = '';
+        else {
+            const key = kv.substring(0, eq);
+            const val = kv.substring(eq + 1);
+            record[key] = val;
+        }
+    }
+    return record;
+};
+const isRecordFieldValue = (k, v) => Array.isArray(v) &&
+    recordFields.includes(k);
+export const pairsToRecords = (obj) => {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [
+        k,
+        k === 'command' && v && typeof v === 'object' ?
+            Object.fromEntries(Object.entries(v).map(([k, v]) => [
+                k,
+                pairsToRecords(v),
+            ]))
+            : isRecordFieldValue(k, v) ? reducePairs(v)
+                : v,
+    ]));
+};
+export const recordsToPairs = (obj) => {
+    return Object.fromEntries(Object.entries(obj)
+        .filter(([k]) => !(k === 'scurry' ||
+        k === 'packageJson' ||
+        k === 'monorepo' ||
+        k === 'projectRoot' ||
+        k === 'packageInfo'))
+        .map(([k, v]) => [
+        k,
+        k === 'command' && v && typeof v === 'object' ?
+            recordsToPairs(v)
+            : (!v ||
+                typeof v !== 'object' ||
+                Array.isArray(v) ||
+                !isRecordField(k)) ?
+                v
+                : Object.entries(v).map(([k, v]) => `${k}=${v}`),
+    ]));
+};
+const kRecord = Symbol('parsed key=value record');
+const exists = (f) => lstat(f).then(() => true, () => false);
+const home = homedir();
+const xdg = new XDG('vlt');
+/**
+ * Class that handles configuration for vlt.
+ *
+ * Call {@link Config.load} to get one of these.
+ */
+export class Config {
+    /**
+     * The {@link https://npmjs.com/jackspeak | JackSpeak} object
+     * representing vlt's configuration
+     */
+    jack;
+    stringifyOptions = { [kIndent]: '  ', [kNewline]: '\n' };
+    configFiles = {};
+    /**
+     * Parsed values in effect
+     */
+    values;
+    /**
+     * Command-specific config values
+     */
+    commandValues = {};
+    /**
+     * A flattened object of the parsed configuration
+     */
+    get options() {
+        if (this.#options)
+            return this.#options;
+        const scurry = new PathScurry(this.projectRoot);
+        const packageJson = new PackageJson();
+        const asRecords = pairsToRecords(this.parse().values);
+        const extras = {
+            projectRoot: this.projectRoot,
+            scurry,
+            packageJson,
+            monorepo: Monorepo.maybeLoad(this.projectRoot, {
+                scurry,
+                packageJson,
+            }),
+        };
+        const options = Object.assign(asRecords, extras);
+        this.#options = Object.assign(options, {
+            packageInfo: new PackageInfoClient(options),
+            [kCustomInspect]() {
+                return Object.fromEntries(Object.entries(options).filter(([k]) => k !== 'monorepo' &&
+                    k !== 'scurry' &&
+                    k !== 'packageJson' &&
+                    k !== 'packageInfo'));
+            },
+        });
+        return this.#options;
+    }
+    /**
+     * Reset the options value, optionally setting a new project root
+     * to recalculate the options.
+     */
+    resetOptions(projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.#options = undefined;
+    }
+    // memoized options() getter value
+    #options;
+    /**
+     * positional arguments to the vlt process
+     */
+    positionals;
+    /**
+     * The root of the project where a vlt.json, vlt-workspaces.json,
+     * package.json, or .git was found. Not necessarily the `process.cwd()`,
+     * though that is the default location.
+     *
+     * Never walks up as far as `$HOME`. So for example, if a project is in
+     * `~/projects/xyz`, then the highest dir it will check is `~/projects`
+     */
+    projectRoot;
+    /**
+     * `Record<alias, canonical name>` to dereference command aliases.
+     */
+    commands;
+    /**
+     * Which command name to use for overriding with command-specific values,
+     * determined from the argv when parse() is called.
+     */
+    command;
+    constructor(jack = definition, projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.commands = commands;
+        this.jack = jack;
+    }
+    /**
+     * Parse the arguments and set configuration and positionals accordingly.
+     */
+    parse(args = process.argv) {
+        if (isParsed(this))
+            return this;
+        this.jack.loadEnvDefaults();
+        const p = this.jack.parseRaw(args);
+        const fallback = getCommand(p.values['fallback-command']);
+        this.command = getCommand(p.positionals[0]);
+        const cmdOrFallback = this.command ?? fallback;
+        const cmdSpecific = cmdOrFallback && this.commandValues[cmdOrFallback];
+        if (cmdSpecific) {
+            this.jack.setConfigValues(recordsToPairs(cmdSpecific));
+        }
+        // ok, applied cmd-specific defaults, do rest of the parse
+        this.jack.applyDefaults(p);
+        this.jack.writeEnv(p);
+        if (this.command)
+            p.positionals.shift();
+        else
+            this.command = getCommand(p.values['fallback-command']);
+        Object.assign(this, p);
+        /* c8 ignore start - unpossible */
+        if (!isParsed(this))
+            throw error('failed to parse config');
+        /* c8 ignore stop */
+        return this;
+    }
+    /**
+     * Get a `key=value` list option value as an object.
+     *
+     * For example, a list option with a vlaue of `['key=value', 'xyz=as=df' ]`
+     * would be returned as `{key: 'value', xyz: 'as=df'}`
+     *
+     * Results are memoized, so subsequent calls for the same key will return the
+     * same object. If new strings are added to the list, then the memoized value
+     * is *not* updated, so only use once configurations have been fully loaded.
+     *
+     * If the config value is not set at all, an empty object is returned.
+     */
+    getRecord(k) {
+        const pairs = this.get(k);
+        if (!pairs)
+            return {};
+        if (pairs[kRecord])
+            return pairs[kRecord];
+        const kv = pairs.reduce((kv, pair) => {
+            const eq = pair.indexOf('=');
+            if (eq === -1)
+                return kv;
+            const key = pair.substring(0, eq);
+            const val = pair.substring(eq + 1);
+            kv[key] = val;
+            return kv;
+        }, {});
+        Object.assign(pairs, { [kRecord]: kv });
+        return kv;
+    }
+    /**
+     * Get a configuration value.
+     *
+     * Note: `key=value` pair configs are returned as a string array. To get them
+     * as an object, use {@link Config#getRecord}.
+     */
+    get(k) {
+        /* c8 ignore next -- impossible but TS doesn't know that */
+        return (this.values ?? this.parse().values)[k];
+    }
+    /**
+     * Write the config values to the user or project config file.
+     */
+    async writeConfigFile(which, values) {
+        const f = this.getFilename(which);
+        await mkdir(dirname(f), { recursive: true });
+        const vals = Object.assign(pairsToRecords(values), this.stringifyOptions);
+        await writeFile(f, jsonStringify(vals));
+        this.configFiles[f] = vals;
+        return values;
+    }
+    /**
+     * Fold in the provided fields with the existing properties
+     * in the config file.
+     */
+    async addConfigToFile(which, values) {
+        const f = this.getFilename(which);
+        return this.writeConfigFile(which, merge((await this.#maybeLoadConfigFile(f)) ?? {}, values));
+    }
+    /**
+     * if the file exists, parse and load it. returns object if data was
+     * loaded, or undefined if not.
+     */
+    async #maybeLoadConfigFile(file) {
+        const result = await this.#readConfigFile(file);
+        if (result) {
+            try {
+                const { command, ...values } = recordsToPairs(result);
+                if (command) {
+                    for (const [c, opts] of Object.entries(command)) {
+                        const cmd = getCommand(c);
+                        if (cmd) {
+                            this.commandValues[cmd] = merge(this.commandValues[cmd] ?? {}, opts);
+                        }
+                    }
+                }
+                this.jack.setConfigValues(values, file);
+                return result;
+            }
+            catch (er) {
+                throw error('failed to load config values from file', {
+                    path: file,
+                    cause: er,
+                });
+            }
+        }
+    }
+    async #readConfigFile(file) {
+        if (this.configFiles[file])
+            return this.configFiles[file];
+        const data = await readFile(file, 'utf8').catch(() => { });
+        if (!data)
+            return undefined;
+        let result;
+        try {
+            result = jsonParse(data);
+            if (result && typeof result === 'object') {
+                if (result[kIndent] !== undefined)
+                    this.stringifyOptions[kIndent] = result[kIndent];
+                if (result[kNewline] !== undefined)
+                    this.stringifyOptions[kNewline] = result[kNewline];
+            }
+        }
+        catch (er) {
+            throw error('failed to parse vlt config file', {
+                path: file,
+                cause: er,
+            });
+        }
+        this.configFiles[file] = result;
+        return result;
+    }
+    getFilename(which = 'project') {
+        return which === 'user' ?
+            xdg.config('vlt.json')
+            : resolve(this.projectRoot, 'vlt.json');
+    }
+    async deleteConfigKeys(which, fields) {
+        const file = this.getFilename(which);
+        const data = await this.#maybeLoadConfigFile(file);
+        if (!data) {
+            rmSync(file, { force: true });
+            return false;
+        }
+        let didSomething = false;
+        for (const f of fields) {
+            const [key, ...sk] = f.split('.');
+            const subs = sk.join('.');
+            const k = key;
+            const v = data[k];
+            if (v === undefined)
+                continue;
+            if (subs && v && typeof v === 'object') {
+                if (Array.isArray(v)) {
+                    const i = v.findIndex(subvalue => subvalue.startsWith(`${subs}=`));
+                    if (i !== -1) {
+                        v.splice(i, 1);
+                        if (v.length === 0)
+                            delete data[k];
+                        didSomething = true;
+                    }
+                }
+                else {
+                    if (v[subs] !== undefined) {
+                        delete v[subs];
+                        if (Object.keys(v).length === 0)
+                            delete data[k];
+                        didSomething = true;
+                    }
+                }
+            }
+            else {
+                didSomething = true;
+                delete data[k];
+            }
+        }
+        const d = jsonStringify(data);
+        if (d.trim() === '{}') {
+            rmSync(file, { force: true });
+        }
+        else {
+            writeFileSync(file, jsonStringify(data));
+        }
+        return didSomething;
+    }
+    /**
+     * Edit the user or project configuration file.
+     *
+     * If the file isn't present, then it starts with `{}` so the user has
+     * something to work with.
+     *
+     * If the result is not valid, or no config settings are contained in the
+     * file after editing, then it's restored to what it was before, which might
+     * mean deleting the file.
+     */
+    async editConfigFile(which, edit) {
+        const file = this.getFilename(which);
+        const backup = this.configFiles[file];
+        if (!backup) {
+            writeFileSync(file, '{\n\n}\n');
+        }
+        let valid = false;
+        try {
+            await edit(file);
+            const res = jsonParse(readFileSync(file, 'utf8'));
+            if (!res || typeof res !== 'object' || Array.isArray(res)) {
+                throw error('Invalid configuration, expected object', {
+                    path: file,
+                    found: res,
+                });
+            }
+            if (Object.keys(res).length === 0) {
+                // nothing there, remove file
+                delete this.configFiles[file];
+                rmSync(file, { force: true });
+            }
+            else {
+                this.jack.setConfigValues(recordsToPairs(res));
+                this.configFiles[file] = res;
+            }
+            valid = true;
+        }
+        finally {
+            if (!valid) {
+                if (backup) {
+                    writeFileSync(file, jsonStringify(backup));
+                }
+                else {
+                    rmSync(file, { force: true });
+                }
+            }
+        }
+    }
+    /**
+     * Find the local config file and load both it and the user-level config in
+     * the XDG config home.
+     *
+     * Note: if working in a workspaces monorepo, then the vlt.json file MUST
+     * be in the same folder as the vlt-workspaces.json file, because we stop
+     * looking when we find either one.
+     */
+    async loadConfigFile() {
+        const userConfig = xdg.config('vlt.json');
+        await this.#maybeLoadConfigFile(userConfig);
+        let lastKnownRoot = resolve(this.projectRoot);
+        for (const dir of walkUp(this.projectRoot)) {
+            // don't look in ~
+            if (dir === home)
+                break;
+            // finding a project config file stops the search
+            const projectConfig = resolve(dir, 'vlt.json');
+            if (projectConfig === userConfig)
+                break;
+            if ((await exists(projectConfig)) &&
+                (await this.#maybeLoadConfigFile(projectConfig))) {
+                lastKnownRoot = dir;
+                break;
+            }
+            // stat existence of these files
+            const [hasPackage, hasModules, hasWorkspaces, hasGit] = await Promise.all([
+                exists(resolve(dir, 'package.json')),
+                exists(resolve(dir, 'node_modules')),
+                exists(resolve(dir, 'vlt-workspaces.json')),
+                exists(resolve(dir, '.git')),
+            ]);
+            // treat these as potential roots
+            if (hasPackage || hasModules || hasWorkspaces) {
+                lastKnownRoot = dir;
+            }
+            // define backstops
+            if (hasWorkspaces || hasGit) {
+                break;
+            }
+        }
+        this.projectRoot = lastKnownRoot;
+        return this;
+    }
+    /**
+     * cache of the loaded config
+     */
+    static #loaded;
+    /**
+     * Load the configuration and return a Promise to a
+     * {@link Config} object
+     */
+    static async load(projectRoot = process.cwd(), argv = process.argv, 
+    /**
+     * only used in tests, resets the memoization
+     * @internal
+     */
+    reload = false) {
+        if (this.#loaded && !reload)
+            return this.#loaded;
+        const a = new Config(definition, projectRoot);
+        const b = await a.loadConfigFile();
+        this.#loaded = b.parse(argv);
+        return this.#loaded;
+    }
+}
+const isParsed = (c) => !!(c.values && c.positionals && c.command);
+//# sourceMappingURL=index.js.map