@vltpkg/vlt-json 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type WhichConfig = 'user' | 'project';
+export type Validator<T> = (x: unknown, file: string) => asserts x is T;
+export declare const unload: (which?: WhichConfig) => void;
+export declare const reload: (field: string, which?: WhichConfig) => unknown;
+export declare const load: <T>(field: string, validator: Validator<T>, which?: WhichConfig) => T | undefined;
+export declare const find: (which?: WhichConfig, cwd?: string, home?: string) => string;
+export declare const save: (field: string, value: unknown, which?: WhichConfig) => void;

package/dist/index.js

@@ -0,0 +1,169 @@
+import { error } from '@vltpkg/error-cause';
+import { XDG } from '@vltpkg/xdg';
+import { lstatSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { walkUp } from 'walk-up-path';
+import { parse as jsonParse, stringify as jsonStringify, kIndent, kNewline, } from 'polite-json';
+const stringifyOptions = {};
+const lstatCache = {};
+const cachedLstat = (path) => {
+    if (path in lstatCache)
+        return lstatCache[path];
+    try {
+        return (lstatCache[path] = lstatSync(path));
+    }
+    catch {
+        delete lstatCache[path];
+        return undefined;
+    }
+};
+const exists = (f) => !!cachedLstat(f);
+const isRecord = (x) => !!x && typeof x === 'object';
+const mtimes = {
+    user: undefined,
+    project: undefined,
+};
+const datas = {
+    user: undefined,
+    project: undefined,
+};
+const validators = {};
+const paths = {
+    user: new XDG('vlt').config('vlt.json'),
+    project: undefined,
+};
+const maybeReadData = (path) => {
+    try {
+        const rawData = jsonParse(readFileSync(path, 'utf8'));
+        if (!isRecord(rawData))
+            return undefined;
+        const so = stringifyOptions[path] ?? {
+            [kIndent]: 2,
+            [kNewline]: '\n',
+        };
+        const { [kNewline]: nl = so[kNewline], [kIndent]: ind = so[kIndent], ...data } = rawData;
+        stringifyOptions[path] = so;
+        stringifyOptions[path][kNewline] = nl;
+        stringifyOptions[path][kIndent] = ind;
+        return data;
+    }
+    catch (er) {
+        throw error('Failed to parse vlt.json file', {
+            path,
+            cause: er,
+        });
+    }
+};
+const loadFullObject = (which) => {
+    if (datas[which])
+        return datas[which];
+    const path = find(which);
+    const mtime = cachedLstat(path)?.mtime.getTime();
+    const data = mtime ? maybeReadData(path) : {};
+    if (mtime && data) {
+        mtimes[which] = mtime;
+    }
+    return (datas[which] = data ?? {});
+};
+const runValidator = (v, x, file) => {
+    if (x !== undefined)
+        v(x, file);
+};
+export const unload = (which = 'project') => {
+    const file = find(which);
+    delete datas[which];
+    delete paths[which];
+    delete lstatCache[file];
+    delete mtimes[which];
+};
+export const reload = (field, which = 'project') => {
+    unload(which);
+    const file = find(which);
+    const data = loadFullObject(which);
+    for (const [field, validator] of Object.entries(validators)) {
+        const value = data[field];
+        runValidator(validator, value, file);
+    }
+    return data[field];
+};
+export const load = (field, validator, which = 'project') => {
+    const data = loadFullObject(which);
+    const file = find(which);
+    validators[field] ??= validator;
+    const value = data[field];
+    if (value !== undefined)
+        validator(value, file);
+    return value;
+};
+export const find = (which = 'project', cwd = process.cwd(), home = homedir()) => {
+    // always resolve the user config path to the XDG location
+    // if caches were unloaded, reinitialize it instead of walking the project tree
+    if (which === 'user') {
+        return (paths.user ??= new XDG('vlt').config('vlt.json'));
+    }
+    if (paths[which])
+        return paths[which];
+    let lastKnownRoot = cwd;
+    for (const dir of walkUp(cwd)) {
+        // don't look in ~
+        if (dir === home)
+            break;
+        const projectConfig = resolve(dir, 'vlt.json');
+        // don't let it match user config
+        if (projectConfig === paths.user)
+            break;
+        // these mean we're done looking
+        if (exists(projectConfig)) {
+            return (paths[which] = projectConfig);
+        }
+        // these are likely candidates, come back if nothing else matches
+        if (exists(resolve(dir, 'package.json')) ||
+            exists(resolve(dir, 'node_modules'))) {
+            lastKnownRoot = dir;
+        }
+        if (exists(resolve(dir, '.git')))
+            break;
+    }
+    return (paths[which] = resolve(lastKnownRoot, 'vlt.json'));
+};
+export const save = (field, value, which = 'project') => {
+    const validator = validators[field];
+    const data = datas[which];
+    if (!validator || !data) {
+        throw error('Cannot save field before loading initially', {
+            name: field,
+            found: value,
+        });
+    }
+    const file = find(which);
+    runValidator(validator, value, file);
+    data[field] = value;
+    const mtime = mtimes[which];
+    const path = find(which);
+    delete lstatCache[path];
+    const updatedMtime = cachedLstat(path)?.mtime.getTime();
+    // if we didn't have a file, and now do, or if we had a file and
+    // it's been changed since we read it, no go.
+    if (updatedMtime && (!mtime || updatedMtime > mtime)) {
+        throw error('File was changed by another process, cannot safely write', {
+            path,
+            name: field,
+            found: value,
+        });
+    }
+    // defines a default indentation and newline in case
+    // a user config file has not yet been read before
+    const extraStringifyOptions = stringifyOptions[path] ?? {};
+    if (!extraStringifyOptions[kIndent]) {
+        extraStringifyOptions[kIndent] = 2;
+    }
+    if (!extraStringifyOptions[kNewline]) {
+        extraStringifyOptions[kNewline] = '\n';
+    }
+    // Ensure the directory exists before writing the file
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, jsonStringify({ ...data, ...extraStringifyOptions }));
+    delete lstatCache[path];
+    mtimes[which] = cachedLstat(path)?.mtime.getTime();
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/vlt-json",
   "description": "utility for finding, reading, and updating the vlt.json file",
-  "version": "1.0.0-rc.22",
+  "version": "1.0.0-rc.24",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -12,8 +12,8 @@
     "email": "support@vlt.sh"
   },
   "dependencies": {
-    "@vltpkg/error-cause": "1.0.0-rc.22",
-    "@vltpkg/xdg": "1.0.0-rc.22",
+    "@vltpkg/error-cause": "1.0.0-rc.24",
+    "@vltpkg/xdg": "1.0.0-rc.24",
     "polite-json": "^5.0.0",
     "walk-up-path": "^4.0.0"
   },
@@ -46,13 +46,13 @@
     "extends": "../../tap-config.yaml"
   },
   "prettier": "../../.prettierrc.js",
-  "module": "./src/index.ts",
+  "module": "./dist/index.js",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
-        "default": "./src/index.ts"
+        "default": "./dist/index.js"
       }
     }
   },