'first'

fcs

2025-04-10 0163870d662dc5b7d69ceff977490ede594f7d82

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
'use strict';
const path = require('path');
const os = require('os');
const fs = require('graceful-fs');
const makeDir = require('make-dir');
const xdgBasedir = require('xdg-basedir');
const writeFileAtomic = require('write-file-atomic');
const dotProp = require('dot-prop');
const uniqueString = require('unique-string');
 
const configDirectory = xdgBasedir.config || path.join(os.tmpdir(), uniqueString());
const permissionError = 'You don\'t have access to this file.';
const makeDirOptions = {mode: 0o0700};
const writeFileOptions = {mode: 0o0600};
 
class Configstore {
    constructor(id, defaults, options = {}) {
        const pathPrefix = options.globalConfigPath ?
            path.join(id, 'config.json') :
            path.join('configstore', `${id}.json`);
 
        this.path = options.configPath || path.join(configDirectory, pathPrefix);
 
        if (defaults) {
            this.all = {
                ...defaults,
                ...this.all
            };
        }
    }
 
    get all() {
        try {
            return JSON.parse(fs.readFileSync(this.path, 'utf8'));
        } catch (error) {
            // Create directory if it doesn't exist
            if (error.code === 'ENOENT') {
                return {};
            }
 
            // Improve the message of permission errors
            if (error.code === 'EACCES') {
                error.message = `${error.message}\n${permissionError}\n`;
            }
 
            // Empty the file if it encounters invalid JSON
            if (error.name === 'SyntaxError') {
                writeFileAtomic.sync(this.path, '', writeFileOptions);
                return {};
            }
 
            throw error;
        }
    }
 
    set all(value) {
        try {
            // Make sure the folder exists as it could have been deleted in the meantime
            makeDir.sync(path.dirname(this.path), makeDirOptions);
 
            writeFileAtomic.sync(this.path, JSON.stringify(value, undefined, '\t'), writeFileOptions);
        } catch (error) {
            // Improve the message of permission errors
            if (error.code === 'EACCES') {
                error.message = `${error.message}\n${permissionError}\n`;
            }
 
            throw error;
        }
    }
 
    get size() {
        return Object.keys(this.all || {}).length;
    }
 
    get(key) {
        return dotProp.get(this.all, key);
    }
 
    set(key, value) {
        const config = this.all;
 
        if (arguments.length === 1) {
            for (const k of Object.keys(key)) {
                dotProp.set(config, k, key[k]);
            }
        } else {
            dotProp.set(config, key, value);
        }
 
        this.all = config;
    }
 
    has(key) {
        return dotProp.has(this.all, key);
    }
 
    delete(key) {
        const config = this.all;
        dotProp.delete(config, key);
        this.all = config;
    }
 
    clear() {
        this.all = {};
    }
}
 
module.exports = Configstore;