@james-pre/config 0.0.1 → 1.0.1

package/dist/node/config.js

@@ -1,351 +0,0 @@
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-// SPDX-License-Identifier: LGPL-3.0-or-later
-import EventEmitter from 'node:events';
-import { mkdirSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join, resolve, sep } from 'node:path';
-import { deepAssign, getByString, memoize, setByString } from 'utilium';
-import * as z from 'zod';
-import { debug, info, warn, writeJSON } from './core.js';
-const kInit = Symbol.for('LoadOptions:init');
-const include = z.string().array().optional();
-function canInclude(options, file) {
-    return (!!options.enableIncludes
-        && typeof file === 'object'
-        && file !== null
-        && 'include' in file
-        && Array.isArray(file.include));
-}
-const xdgConfigDir = process.env.XDG_CONFIG_HOME
-    || (process.platform == 'win32' ? process.env.APPDATA : null)
-    || join(homedir(), '.config');
-const systemConfigDir = (process.platform == 'win32' ? process.env.PROGRAMDATA : null) || '/etc';
-function typeFromPath(path) {
-    if (path.startsWith(systemConfigDir + sep))
-        return 'system';
-    if (path.startsWith(xdgConfigDir + sep))
-        return 'user';
-    return 'local';
-}
-/** Resolve a `ManagerOptions` path, which may omit the `.json` extension */
-function withExtension(path) {
-    return path.endsWith('.json') ? path : path + '.json';
-}
-/**
- * Remove `.default()` and `.prefault()` from a schema and everything nested within it.
- */
-function stripDefaults(schema) {
-    const def = schema._zod.def;
-    switch (def.type) {
-        case 'default':
-        case 'prefault':
-            return stripDefaults(def.innerType);
-        case 'object':
-            return z.core.clone(schema, {
-                ...def,
-                shape: Object.fromEntries(Object.entries(def.shape).map(([key, member]) => [key, stripDefaults(member)])),
-                catchall: def.catchall && stripDefaults(def.catchall),
-            });
-        case 'array':
-            return z.core.clone(schema, { ...def, element: stripDefaults(def.element) });
-        case 'record':
-        case 'map':
-        case 'set':
-            return z.core.clone(schema, { ...def, valueType: stripDefaults(def.valueType) });
-        case 'union':
-            return z.core.clone(schema, { ...def, options: def.options.map(stripDefaults) });
-        case 'tuple':
-            return z.core.clone(schema, {
-                ...def,
-                items: def.items.map(stripDefaults),
-                rest: def.rest && stripDefaults(def.rest),
-            });
-        case 'optional':
-        case 'nullable':
-        case 'readonly':
-        case 'nonoptional':
-        case 'catch':
-            return z.core.clone(schema, { ...def, innerType: stripDefaults(def.innerType) });
-        default:
-            return schema;
-    }
-}
-/**
- * Compute a schema's default value from `.default()` on it and on anything nested within it.
- * Members without a default are left out, so the result is not necessarily a complete config.
- */
-function defaultsOf(schema) {
-    const def = schema._zod.def;
-    switch (def.type) {
-        case 'default':
-        case 'prefault':
-        case 'catch':
-            try {
-                return schema.parse(undefined);
-            }
-            catch {
-                return defaultsOf(def.innerType);
-            }
-        case 'object': {
-            const value = {};
-            for (const [key, member] of Object.entries(def.shape)) {
-                const inner = defaultsOf(member);
-                if (inner !== undefined)
-                    value[key] = inner;
-            }
-            return Object.keys(value).length ? value : undefined;
-        }
-        default:
-            return def.innerType ? defaultsOf(def.innerType) : undefined;
-    }
-}
-/**
- * Manage for configuration files
- */
-let Manager = (() => {
-    let _classSuper = EventEmitter;
-    let _instanceExtraInitializers = [];
-    let _get_defaultPaths_decorators;
-    return class Manager extends _classSuper {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _get_defaultPaths_decorators = [memoize];
-            __esDecorate(this, null, _get_defaultPaths_decorators, { kind: "getter", name: "defaultPaths", static: false, private: false, access: { has: obj => "defaultPaths" in obj, get: obj => obj.defaultPaths }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        options = __runInitializers(this, _instanceExtraInitializers);
-        schema;
-        fileSchema;
-        files = new Map();
-        data;
-        constructor(shape, options = {}) {
-            super({ captureRejections: true });
-            this.options = options;
-            this.schema = z.object(shape);
-            this.fileSchema = z.deepPartial(stripDefaults(z.object(options.enableIncludes ? { ...shape, include } : shape)));
-            this.data = this.defaults;
-        }
-        /**
-         * A fresh config with only the schema's defaults applied.
-         */
-        get defaults() {
-            return structuredClone(defaultsOf(this.schema) ?? {});
-        }
-        get(key) {
-            return getByString(this.data, key);
-        }
-        set(key, value) {
-            setByString(this.data, key, value);
-        }
-        /**
-         * Deeply merge `config` into the current config. Arrays are replaced rather than combined.
-         */
-        merge(config) {
-            deepAssign(this.data, structuredClone(config), { replaceArrays: true });
-            this.emit('change');
-        }
-        /** Replace the current config with `config`, applying defaults for anything missing. */
-        replace(config) {
-            for (const key of Object.keys(this.data))
-                delete this.data[key];
-            Object.assign(this.data, this.schema.parse(config));
-            this.emit('change');
-        }
-        loadFile(path, options) {
-            if (this.files.has(path))
-                return;
-            let json;
-            try {
-                json = JSON.parse(readFileSync(path, 'utf8'));
-            }
-            catch (e) {
-                if (!options.create || e.code != 'ENOENT') {
-                    if (!options.optional)
-                        throw e;
-                    if (!this.emit('load_error', path, 'read', e)) {
-                        debug(`Skipping config at ${path} (${e.message})`);
-                    }
-                    return;
-                }
-                try {
-                    mkdirSync(dirname(path), { recursive: true });
-                    writeJSON(path, {});
-                }
-                catch (e) {
-                    if (!options.optional)
-                        throw e;
-                    if (!this.emit('load_error', path, 'create', e)) {
-                        warn(`Failed to create config at ${path} (${e.message})`);
-                    }
-                    return;
-                }
-                debug('Created config: ' + path);
-                json = {};
-            }
-            let file;
-            try {
-                file = this.fileSchema.parse(json);
-            }
-            catch (e) {
-                if (!options.loose)
-                    throw e;
-                if (!this.emit('load_error', path, 'parse', e)) {
-                    debug(`Loading invalid config from ${path} (${e.message})`);
-                }
-                file = json;
-            }
-            this.files.set(path, {
-                auto: false,
-                wasIncluded: false,
-                type: typeFromPath(path),
-                ...(options[kInit] || {}),
-                data: file,
-                path,
-            });
-            this.merge(file);
-            debug('Loaded config: ' + path);
-            if (canInclude(this.options, file))
-                for (const include of file.include ?? []) {
-                    this.loadFile(resolve(dirname(path), include), {
-                        ...options,
-                        optional: true,
-                        create: false,
-                        [kInit]: { ...options[kInit], wasIncluded: true },
-                    });
-                }
-            this.emit('load', path, file);
-        }
-        /** Get the entry for `path`, adding one for a file that has not been loaded */
-        fileAt(path) {
-            const existing = this.files.get(path);
-            if (existing)
-                return existing;
-            const file = {
-                path,
-                data: {},
-                type: typeFromPath(path),
-                auto: false,
-                wasIncluded: false,
-            };
-            this.files.set(path, file);
-            return file;
-        }
-        writeFile(file) {
-            mkdirSync(dirname(file.path), { recursive: true });
-            writeJSON(file.path, file.data);
-            debug('Wrote config: ' + file.path);
-        }
-        /**
-         * Replace the contents of the config file at `path` and write it,
-         * then rebuild the current config from the defaults and all loaded files.
-         */
-        replaceFile(path, config) {
-            const file = this.fileAt(path);
-            file.data = this.fileSchema.parse(config);
-            this.writeFile(file);
-            this.replace(this.defaults);
-            for (const file of this.files.values())
-                this.merge(file.data);
-        }
-        /**
-         * Merge `config` into the current config and into the config file at `path`, then write it.
-         */
-        updateFile(path, config) {
-            const file = this.fileAt(path);
-            deepAssign(file.data, this.fileSchema.parse(config), { replaceArrays: true });
-            this.merge(config);
-            this.writeFile(file);
-        }
-        /**
-         * The files `loadDefaults` will try to load, ordered from most global to most local.
-         * @internal
-         */
-        get defaultPaths() {
-            const paths = [];
-            const { system, xdg } = this.options;
-            if (system)
-                paths.push({ type: 'system', path: join(systemConfigDir, withExtension(system)) });
-            if (xdg)
-                paths.push({ type: 'user', path: join(xdgConfigDir, withExtension(xdg)) });
-            return paths;
-        }
-        /**
-         * Load the files from `defaultPaths`. Missing files are skipped unless `options` says otherwise.
-         */
-        loadDefaults(options) {
-            for (const { path, type } of this.defaultPaths) {
-                this.loadFile(path, { optional: true, ...options, [kInit]: { type, auto: true } });
-            }
-        }
-        /**
-         * The file a change of the given type is written to:
-         * the most recently loaded file of that type, or the path `loadDefaults` would use for it.
-         */
-        findPath(type) {
-            const loaded = this.files
-                .values()
-                .filter(file => (!type || file.type == type) && !file.wasIncluded)
-                .map(file => file.path)
-                .toArray();
-            if (loaded.length)
-                return loaded.at(-1);
-            // Without a type, fall back to the most local default path
-            const fallback = type ? this.defaultPaths.find(entry => entry.type == type) : this.defaultPaths.at(-1);
-            if (!fallback)
-                throw new Error(`No ${type ?? 'writable'} configuration file to write to`);
-            return fallback.path;
-        }
-        /**
-         * Merge `config` into the current config and save it.
-         */
-        update(config, type) {
-            this.updateFile(this.findPath(type), config);
-        }
-        reloadFiles(options) {
-            const files = this.files
-                .values()
-                .filter(file => !file.wasIncluded)
-                .toArray();
-            this.files.clear();
-            this.replace(this.defaults);
-            for (const file of files) {
-                this.loadFile(file.path, { ...options, [kInit]: { type: file.type, auto: file.auto } });
-            }
-            info('Reloaded configuration files');
-        }
-    };
-})();
-export { Manager };

package/dist/node/core.d.ts

@@ -1,7 +0,0 @@
-import type * as z from 'zod';
-export * from '../core.js';
-/**
- * @param defaultValue Returned when the file can't be loaded. If omitted, loading errors will be thrown.
- */
-export declare function readJSON<S extends z.ZodType>(path: string, schema: S): z.infer<S>;
-export declare function writeJSON(path: string, data: any): void;

package/dist/node/core.js

@@ -1,198 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-/* eslint-disable @typescript-eslint/only-throw-error */
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { readFileSync, writeFileSync } from 'node:fs';
-import { styleText } from 'node:util';
-import * as io from '../core.js';
-export * from '../core.js';
-let _currentOperation = null, _progress = null;
-function clearLine() {
-    if (!process.stdout.isTTY)
-        return;
-    process.stdout.clearLine(0);
-    process.stdout.cursorTo(0);
-}
-function handleProgress() {
-    if (!_currentOperation)
-        return { [Symbol.dispose]() { } };
-    clearLine();
-    return {
-        [Symbol.dispose]() {
-            process.stdout.write(_currentOperation + '... ');
-            if (_progress)
-                io.progress(..._progress);
-        },
-    };
-}
-io.useProgress({
-    start(message) {
-        _currentOperation = message;
-        process.stdout.write(message + '... ');
-    },
-    progress(value, max, message, text) {
-        _progress = [value, max];
-        clearLine();
-        process.stdout.write(`${_currentOperation}... ${text || value.toString().padStart(max.toString().length) + '/' + max} ${message && value < max ? `(${message})` : ''}`);
-        if (value >= max) {
-            _currentOperation = null;
-            _progress = null;
-            console.log();
-        }
-    },
-    done(noPrint) {
-        _currentOperation = null;
-        _progress = null;
-        if (!noPrint)
-            console.log('done.');
-    },
-});
-function* maybeStyle(style, parts) {
-    for (const part of parts) {
-        if (typeof part != 'string')
-            yield part;
-        else if (part.startsWith('\x1b'))
-            yield part;
-        else
-            yield styleText(style, part);
-    }
-}
-io.useOutput({
-    error(...message) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_1, handleProgress(), false);
-            console.error(...maybeStyle('red', message));
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    },
-    warn(...message) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_2, handleProgress(), false);
-            console.warn(...maybeStyle('yellow', message));
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            __disposeResources(env_2);
-        }
-    },
-    info(...message) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_3, handleProgress(), false);
-            console.info(...maybeStyle('blue', message));
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            __disposeResources(env_3);
-        }
-    },
-    log(...message) {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_4, handleProgress(), false);
-            console.log(...message);
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            __disposeResources(env_4);
-        }
-    },
-    debug(...message) {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            if (!io._debugOutput)
-                return;
-            const _ = __addDisposableResource(env_5, handleProgress(), false);
-            console.debug(...maybeStyle('gray', message));
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            __disposeResources(env_5);
-        }
-    },
-});
-/**
- * @param defaultValue Returned when the file can't be loaded. If omitted, loading errors will be thrown.
- */
-export function readJSON(path, schema) {
-    try {
-        const data = JSON.parse(readFileSync(path, 'utf-8'));
-        return schema.parse(data);
-    }
-    catch (e) {
-        throw io.errorText(e);
-    }
-}
-export function writeJSON(path, data) {
-    writeFileSync(path, JSON.stringify(data, null, '\t'), 'utf-8');
-}

package/dist/node/index.d.ts

@@ -1,7 +0,0 @@
-export * from '../table.js';
-export * from '../tracking.js';
-export * from './core.js';
-export * as jobs from './jobs.js';
-export * from './process.js';
-export * from './rl.js';
-export * as config from './config.js';

package/dist/node/index.js

@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-import { stripVTControlCharacters } from 'node:util';
-import { setANSIStripper, setTableTargetWidth } from '../table.js';
-setANSIStripper(stripVTControlCharacters);
-if (process.stdout.isTTY) {
-    setTableTargetWidth(process.stdout.columns);
-    process.stdout.on('resize', () => {
-        setTableTargetWidth(process.stdout.columns);
-    });
-}
-export * from '../table.js';
-export * from '../tracking.js';
-export * from './core.js';
-export * as jobs from './jobs.js';
-export * from './process.js';
-export * from './rl.js';
-export * as config from './config.js';

package/dist/node/jobs.d.ts

@@ -1,11 +0,0 @@
-import * as jobs from '../jobs.js';
-export * from '../jobs.js';
-export interface CommandData {
-    argv: string[];
-    name?: string;
-}
-export interface CommandOptions extends jobs.Options {
-    parseLine?(rawLine: string, isStderr: boolean): string;
-    successText?: string;
-}
-export declare function runCommands(options: CommandOptions, commands: CommandData[]): Promise<jobs.Results>;

package/dist/node/jobs.js

@@ -1,76 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-import { spawn } from 'node:child_process';
-import * as jobs from '../jobs.js';
-import { styleText } from 'node:util';
-import { errorText } from '../core.js';
-export * from '../jobs.js';
-const isTTY = !!process.stdout.isTTY && !!process.stderr.isTTY;
-jobs.useClear(lastDrawLineCount => {
-    process.stdout.moveCursor(0, -lastDrawLineCount);
-    process.stdout.clearScreenDown();
-});
-jobs.useDraw((lines) => {
-    for (const line of lines)
-        process.stdout.write(line + '\n');
-});
-jobs.useResultFormat(result => result.status == 'failed'
-    ? styleText('red', result.text?.toString() ?? 'failed')
-    : (result.text?.toString() ?? styleText('green', 'done')));
-if (!isTTY)
-    jobs._disableInPlaceUpdates();
-async function runCommand(data, progress) {
-    const [command, ...args] = data.argv;
-    const options = this;
-    const child = spawn(command, args, {
-        stdio: [
-            'ignore',
-            // stdout: ignore in TTY mode (we synthesize our own status), inherit otherwise
-            isTTY ? 'pipe' : 'inherit',
-            // stderr: parse in TTY mode, inherit otherwise
-            isTTY ? 'pipe' : 'inherit',
-        ],
-    });
-    let failText = null, failSetFromThrow = false;
-    function handleStream(stream, isErr) {
-        if (!isTTY || !stream)
-            return;
-        let buf = '';
-        stream.on('data', (chunk) => {
-            buf += chunk.toString('utf8');
-            const lines = buf.split(/[\r\n]+/);
-            buf = lines.pop() ?? '';
-            for (const rawLine of lines) {
-                let line = rawLine.trim();
-                if (!line)
-                    continue;
-                try {
-                    line = options.parseLine?.(line, isErr) ?? line;
-                    if (isErr && !failSetFromThrow)
-                        failText ||= line;
-                }
-                catch (e) {
-                    line = errorText(e);
-                    failText = line;
-                    failSetFromThrow = true;
-                }
-                progress(line);
-            }
-        });
-    }
-    handleStream(child.stdout, false);
-    handleStream(child.stderr, true);
-    const { promise: close, resolve } = Promise.withResolvers();
-    child.on('close', resolve);
-    const code = await close;
-    return code === 0
-        ? { status: 'succeeded', text: options.successText ?? styleText('green', 'done') }
-        : { status: 'failed', text: failText ?? (code ? `failed (${code})` : 'failed') };
-}
-export async function runCommands(options, commands) {
-    return await jobs.runWithData({
-        ...options,
-        jobStartText: styleText('cyan', 'starting...'),
-        run: runCommand.bind(options),
-        name: cmd => cmd.name,
-    }, commands);
-}