@spyglassmc/core 0.1.0

package/lib/service/CacheService.js

@@ -0,0 +1,195 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _CacheService_cacheFilePath;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheService = exports.LatestCacheVersion = void 0;
+const path_1 = __importDefault(require("path"));
+const common_1 = require("../common");
+const symbol_1 = require("../symbol");
+const fileUtil_1 = require("./fileUtil");
+/**
+ * The format version of the cache. Should be increased when any changes that
+ * could invalidate the cache are introduced to the Spyglass codebase.
+ */
+exports.LatestCacheVersion = 1;
+var Checksums;
+(function (Checksums) {
+    function create() {
+        return {
+            files: {},
+            roots: {},
+            symbolRegistrars: {},
+        };
+    }
+    Checksums.create = create;
+})(Checksums || (Checksums = {}));
+class CacheService {
+    /**
+     * @param cacheRoot File path to the directory where cache files by Spyglass should be stored.
+     * @param project
+     */
+    constructor(cacheRoot, project) {
+        this.cacheRoot = cacheRoot;
+        this.project = project;
+        this.checksums = Checksums.create();
+        _CacheService_cacheFilePath.set(this, void 0);
+        this.project.on('documentUpdated', ({ doc }) => {
+            try {
+                // TODO: Don't update this for every single change.
+                this.checksums.files[doc.uri] = (0, common_1.getSha1)(doc.getText());
+            }
+            catch (e) {
+                if (!(0, common_1.isErrorCode)(e, 'EISDIR')) {
+                    this.project.logger.error(`[CacheService#hash-file] ${doc.uri}`);
+                }
+            }
+        });
+        this.project.on('rootsUpdated', async ({ roots }) => {
+            for (const root of roots) {
+                try {
+                    this.checksums.roots[root] = await this.project.fs.hash(root);
+                }
+                catch (e) {
+                    if (!(0, common_1.isErrorCode)(e, 'EISDIR')) {
+                        this.project.logger.error(`[CacheService#hash-root] ${root}`);
+                    }
+                }
+            }
+        });
+        this.project.on('symbolRegistrarExecuted', ({ id, checksum }) => {
+            if (checksum !== undefined) {
+                this.checksums.symbolRegistrars[id] = checksum;
+            }
+        });
+    }
+    /**
+     * @throws
+     *
+     * @returns `${cacheRoot}/symbols/${sha1(projectRoot)}.json`
+     */
+    getCacheFilePath() {
+        return __classPrivateFieldSet(this, _CacheService_cacheFilePath, __classPrivateFieldGet(this, _CacheService_cacheFilePath, "f") ?? path_1.default.join(this.cacheRoot, 'symbols', `${(0, common_1.getSha1)(this.project.projectRoot)}.json.gz`), "f");
+    }
+    async load() {
+        const __profiler = this.project.profilers.get('cache#load');
+        const ans = { symbols: {} };
+        let filePath;
+        try {
+            filePath = this.getCacheFilePath();
+            const cache = await fileUtil_1.fileUtil.readGzippedJson(filePath);
+            __profiler.task('Read File');
+            if (cache.version === exports.LatestCacheVersion) {
+                this.checksums = cache.checksums;
+                ans.symbols = symbol_1.SymbolTable.link(cache.symbols);
+                __profiler.task('Link Symbols');
+            }
+            else {
+                this.project.logger.info(`[CacheService#load] Unsupported cache format ${cache.version}; expected ${exports.LatestCacheVersion}`);
+            }
+        }
+        catch (e) {
+            if (!(0, common_1.isEnoent)(e)) {
+                this.project.logger.error(`[CacheService#load] path = “${filePath}”`, e);
+            }
+        }
+        __profiler.finalize();
+        return ans;
+    }
+    async validate() {
+        const ans = {
+            addedFiles: [],
+            changedFiles: [],
+            removedFiles: [],
+            unchangedFiles: [],
+        };
+        const unchangedRoots = [];
+        for (const [uri, checksum] of Object.entries(this.checksums.roots)) {
+            try {
+                const hash = await this.project.fs.hash(uri);
+                if (hash === checksum) {
+                    unchangedRoots.push(uri);
+                }
+            }
+            catch (e) {
+                if (!(0, common_1.isErrorCode)(e, 'EISDIR')) {
+                    this.project.logger.error(`[CacheService#hash-file] ${uri}`);
+                }
+                // Failed calculating hash. Assume the root has changed.
+            }
+        }
+        for (const [uri, checksum] of Object.entries(this.checksums.files)) {
+            if (unchangedRoots.some(root => uri.startsWith(root))) {
+                ans.unchangedFiles.push(uri);
+                continue;
+            }
+            try {
+                const hash = await this.project.fs.hash(uri);
+                if (hash === checksum) {
+                    ans.unchangedFiles.push(uri);
+                }
+                else {
+                    ans.changedFiles.push(uri);
+                }
+            }
+            catch (e) {
+                if ((0, common_1.isEnoent)(e) || (0, common_1.isErrorCode)(e, 'EISDIR')) {
+                    ans.removedFiles.push(uri);
+                }
+                else {
+                    this.project.logger.error(`[CacheService#validate] ${uri}`, e);
+                    // Assume the file has changed.
+                    ans.changedFiles.push(uri);
+                }
+            }
+        }
+        for (const uri of this.project.getTrackedFiles()) {
+            if (!(uri in this.checksums.files)) {
+                ans.addedFiles.push(uri);
+            }
+        }
+        return ans;
+    }
+    /**
+     * @returns If the cache file was saved successfully.
+     */
+    async save() {
+        const __profiler = this.project.profilers.get('cache#save');
+        let filePath;
+        try {
+            filePath = this.getCacheFilePath();
+            const cache = {
+                checksums: this.checksums,
+                projectRoot: this.project.projectRoot,
+                symbols: symbol_1.SymbolTable.unlink(this.project.symbols.global),
+                version: exports.LatestCacheVersion,
+            };
+            __profiler.task('Unlink Symbols');
+            await fileUtil_1.fileUtil.writeGzippedJson(filePath, cache);
+            __profiler.task('Write File').finalize();
+            return true;
+        }
+        catch (e) {
+            this.project.logger.error(`[CacheService#save] path = “${filePath}”`, e);
+        }
+        return false;
+    }
+    reset() {
+        this.checksums = Checksums.create();
+    }
+}
+exports.CacheService = CacheService;
+_CacheService_cacheFilePath = new WeakMap();
+//# sourceMappingURL=CacheService.js.map

package/lib/service/CommandExecutor.d.ts

@@ -0,0 +1,3 @@
+export declare class CommandExecutor {
+}
+//# sourceMappingURL=CommandExecutor.d.ts.map

package/lib/service/CommandExecutor.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandExecutor = void 0;
+class CommandExecutor {
+}
+exports.CommandExecutor = CommandExecutor;
+//# sourceMappingURL=CommandExecutor.js.map

package/lib/service/Config.d.ts

@@ -0,0 +1,218 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Arrayable } from '../common';
+import { ErrorSeverity } from '../source';
+import type { Project } from './Project';
+export interface Config {
+    /**
+     * Environment settings. Unlike other configs, all involved root folders must have the same `env` settings. It is undocumented
+     * what would happen if two roots have conflicting `env` settings.
+     */
+    env: EnvConfig;
+    /**
+     * Formatter rules.
+     */
+    format: FormatterConfig;
+    /**
+     *t Linter rules.
+     */
+    lint: LinterConfig;
+    /**
+     * Code snippets.
+     */
+    snippet: SnippetsConfig;
+}
+export interface EnvConfig {
+    /**
+     * Where to download data like `mcmeta` or `mc-nbtdoc` from (case-insensitive).
+     *
+     * * `GitHub`
+     * * `jsDelivr`: Not recommended as files from there can be outdated. Only use this if you have trouble connecting to `raw.githubusercontent.com`.
+     */
+    dataSource: string;
+    /**
+     * A list of data packs the current project depends on. Each value in this array can be either an absolute file path
+     * to a data pack folder or data pack archive (e.g. `.zip` or `.tar.gz`), or a special string like `@mc-nbtdoc`.
+     */
+    dependencies: string[];
+    feature: {
+        codeActions: boolean;
+        colors: boolean;
+        completions: boolean;
+        documentHighlighting: boolean;
+        documentLinks: boolean;
+        foldingRanges: boolean;
+        formatting: boolean;
+        hover: boolean;
+        inlayHint: boolean | {
+            enabledNodes: string[];
+        };
+        semanticColoring: boolean;
+        selectionRanges: boolean;
+        signatures: boolean;
+    };
+    /**
+     * This field is case-insensitive.
+     *
+     * - `Auto`: Auto infer from `pack.mcmeta`.
+     * - `Latest release`
+     * - `Latest snapshot`
+     * - A version identifier or name found in [mcmeta's version data](https://github.com/misode/mcmeta/blob/summary/versions/data.json) that is older than `1.15` (inclusive).
+     */
+    gameVersion: string;
+    /**
+     * Locale language for error messages and other texts provided by Spyglass.
+     */
+    language: string;
+    /**
+     * Use custom files as mcmeta summaries.
+     *
+     * // TODO: Support file paths relative to the project root.
+     */
+    mcmetaSummaryOverrides: Partial<Record<'blocks' | 'commands' | 'fluids' | 'registries', {
+        path: string;
+        replace?: boolean;
+    }>>;
+    permissionLevel: 1 | 2 | 3 | 4;
+    plugins: string[];
+}
+export declare type LinterSeverity = 'hint' | 'information' | 'warning' | 'error';
+export declare namespace LinterSeverity {
+    function is(value: unknown): value is LinterSeverity;
+    function toErrorSeverity(value: LinterSeverity): ErrorSeverity;
+}
+declare type BracketSpacingConfig = any;
+declare type SepSpacingConfig = any;
+export declare type QuoteConfig = {
+    always?: boolean;
+    avoidEscape?: boolean | null;
+    type?: 'double' | 'single';
+};
+declare type LinterConfigValue<T> = T extends boolean ? null | T | [LinterSeverity, T] | LinterSeverity : null | T | [LinterSeverity, T];
+export declare namespace LinterConfigValue {
+    function destruct(value: LinterConfigValue<boolean | string | number | object>): {
+        ruleSeverity: ErrorSeverity;
+        ruleValue: boolean | string | number | object;
+    } | undefined;
+}
+export interface FormatterConfig {
+    blockStateBracketSpacing: BracketSpacingConfig;
+    blockStateCommaSpacing: SepSpacingConfig;
+    blockStateEqualSpacing: SepSpacingConfig;
+    blockStateTrailingComma: boolean;
+    eol: 'auto' | 'CRLF' | 'LF';
+    nbtArrayBracketSpacing: BracketSpacingConfig;
+    nbtArrayCommaSpacing: SepSpacingConfig;
+    nbtArraySemicolonSpacing: {
+        after: number;
+    };
+    nbtArrayTrailingComma: boolean;
+    nbtByteSuffix: 'b' | 'B';
+    nbtCompoundBracketSpacing: BracketSpacingConfig;
+    nbtCompoundColonSpacing: SepSpacingConfig;
+    nbtCompoundCommaSpacing: SepSpacingConfig;
+    nbtCompoundTrailingComma: boolean;
+    nbtDoubleOmitSuffix: boolean;
+    nbtDoubleSuffix: 'd' | 'D';
+    nbtFloatSuffix: 'f' | 'F';
+    nbtListBracketSpacing: BracketSpacingConfig;
+    nbtListCommaSpacing: SepSpacingConfig;
+    nbtListTrailingComma: boolean;
+    nbtLongSuffix: 'l' | 'L';
+    nbtShortSuffix: 's' | 'S';
+    selectorBracketSpacing: BracketSpacingConfig;
+    selectorCommaSpacing: SepSpacingConfig;
+    selectorEqualSpacing: SepSpacingConfig;
+    selectorTrailingComma: boolean;
+    timeOmitTickUnit: boolean;
+}
+export interface LinterConfig {
+    blockStateSortKeys: LinterConfigValue<'alphabetically'>;
+    nbtCompoundSortKeys: LinterConfigValue<'alphabetically'>;
+    selectorSortKeys: LinterConfigValue<string[]>;
+    commandStringQuote: LinterConfigValue<QuoteConfig>;
+    nbtKeyQuote: LinterConfigValue<QuoteConfig>;
+    nbtPathQuote: LinterConfigValue<QuoteConfig>;
+    nbtStringQuote: LinterConfigValue<QuoteConfig>;
+    selectorKeyQuote: LinterConfigValue<QuoteConfig>;
+    idOmitDefaultNamespace: LinterConfigValue<boolean>;
+    nameOfNbtKey: LinterConfigValue<string>;
+    nameOfObjective: LinterConfigValue<string>;
+    nameOfScoreHolder: LinterConfigValue<string>;
+    nameOfTag: LinterConfigValue<string>;
+    nameOfTeam: LinterConfigValue<string>;
+    nbtArrayLengthCheck: LinterConfigValue<boolean>;
+    nbtBoolean: LinterConfigValue<boolean>;
+    nbtListLengthCheck: LinterConfigValue<boolean>;
+    nbtTypeCheck: LinterConfigValue<'strictly' | 'loosely'>;
+    undeclaredSymbol: LinterConfigValue<SymbolLinterConfig>;
+}
+export interface SnippetsConfig {
+    [label: string]: string;
+}
+export declare type SymbolLinterConfig = Arrayable<SymbolLinterConfig.Complex> | SymbolLinterConfig.Action;
+export declare namespace SymbolLinterConfig {
+    function is(value: unknown): value is SymbolLinterConfig;
+    interface Complex {
+        /**
+         * {@link Condition}s in this array are connected with OR.
+         */
+        if?: Arrayable<Condition>;
+        then?: Action;
+        override?: Arrayable<Complex>;
+    }
+    namespace Complex {
+        function is(v: unknown): v is Complex;
+    }
+    interface Condition {
+        category?: Arrayable<string>;
+        pattern?: Arrayable<string>;
+        excludePattern?: Arrayable<string>;
+        namespace?: Arrayable<string>;
+        excludeNamespace?: Arrayable<string>;
+    }
+    namespace Condition {
+        function is(v: unknown): v is Condition;
+    }
+    interface DeclareAction {
+        declare: 'block' | 'file' | 'public';
+    }
+    interface ReportAction {
+        report: LinterSeverity | 'inherit';
+    }
+    type Action = DeclareAction | ReportAction;
+    namespace Action {
+        function isDeclare(value: Action | undefined): value is DeclareAction;
+        function isReport(value: Action | undefined): value is ReportAction;
+        function is(v: unknown): v is Action;
+    }
+}
+/**
+* Config which simulates the default vanilla command system.
+*/
+export declare const VanillaConfig: Config;
+declare type ConfigEvent = {
+    config: Config;
+};
+declare type ErrorEvent = {
+    error: unknown;
+    uri: string;
+};
+export interface ConfigService {
+    on(event: 'changed', callbackFn: (data: ConfigEvent) => void): this;
+    on(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
+    once(event: 'changed', callbackFn: (data: ConfigEvent) => void): this;
+    once(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
+    emit(event: 'changed', data: ConfigEvent): boolean;
+    emit(event: 'error', data: ErrorEvent): boolean;
+}
+export declare class ConfigService extends EventEmitter {
+    private readonly project;
+    static readonly ConfigFileNames: readonly ["spyglass.json", ".spyglassrc.json"];
+    constructor(project: Project);
+    load(): Promise<Config>;
+    private static isConfigFile;
+    private merge;
+}
+export {};
+//# sourceMappingURL=Config.d.ts.map

package/lib/service/Config.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = exports.VanillaConfig = exports.SymbolLinterConfig = exports.LinterConfigValue = exports.LinterSeverity = void 0;
+const events_1 = __importDefault(require("events"));
+const fs_1 = require("fs");
+const rfdc_1 = __importDefault(require("rfdc"));
+const common_1 = require("../common");
+const symbol_1 = require("../symbol");
+var LinterSeverity;
+(function (LinterSeverity) {
+    function is(value) {
+        return value === 'hint' ||
+            value === 'information' ||
+            value === 'warning' ||
+            value === 'error';
+    }
+    LinterSeverity.is = is;
+    function toErrorSeverity(value) {
+        switch (value) {
+            case 'error':
+                return 3 /* Error */;
+            case 'hint':
+                return 0 /* Hint */;
+            case 'information':
+                return 1 /* Information */;
+            case 'warning':
+                return 2 /* Warning */;
+        }
+    }
+    LinterSeverity.toErrorSeverity = toErrorSeverity;
+})(LinterSeverity = exports.LinterSeverity || (exports.LinterSeverity = {}));
+var LinterConfigValue;
+(function (LinterConfigValue) {
+    function destruct(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (LinterSeverity.is(value)) {
+            return {
+                ruleSeverity: LinterSeverity.toErrorSeverity(value),
+                ruleValue: true,
+            };
+        }
+        if (Array.isArray(value) && LinterSeverity.is(value[0])) {
+            return {
+                ruleSeverity: LinterSeverity.toErrorSeverity(value[0]),
+                ruleValue: value[1],
+            };
+        }
+        return {
+            ruleSeverity: 2 /* Warning */,
+            ruleValue: value,
+        };
+    }
+    LinterConfigValue.destruct = destruct;
+})(LinterConfigValue = exports.LinterConfigValue || (exports.LinterConfigValue = {}));
+var SymbolLinterConfig;
+(function (SymbolLinterConfig) {
+    function is(value) {
+        return common_1.Arrayable.is(value, Complex.is) || Action.is(value);
+    }
+    SymbolLinterConfig.is = is;
+    let Complex;
+    (function (Complex) {
+        function is(v) {
+            if (!v || typeof v !== 'object') {
+                return false;
+            }
+            const value = v;
+            return ((value.if === undefined || common_1.Arrayable.is(value.if, Condition.is)) &&
+                (value.then === undefined || Action.is(value.then)) &&
+                (value.override === undefined || common_1.Arrayable.is(value.override, Complex.is)));
+        }
+        Complex.is = is;
+    })(Complex = SymbolLinterConfig.Complex || (SymbolLinterConfig.Complex = {}));
+    let Condition;
+    (function (Condition) {
+        function is(v) {
+            if (!v || typeof v !== 'object') {
+                return false;
+            }
+            const value = v;
+            return ((value.category === undefined || common_1.Arrayable.is(value.category, common_1.TypePredicates.isString)) &&
+                (value.pattern === undefined || common_1.Arrayable.is(value.pattern, common_1.TypePredicates.isString)) &&
+                (value.excludePattern === undefined || common_1.Arrayable.is(value.excludePattern, common_1.TypePredicates.isString)) &&
+                (value.namespace === undefined || common_1.Arrayable.is(value.namespace, common_1.TypePredicates.isString)) &&
+                (value.excludeNamespace === undefined || common_1.Arrayable.is(value.excludeNamespace, common_1.TypePredicates.isString)));
+        }
+        Condition.is = is;
+    })(Condition = SymbolLinterConfig.Condition || (SymbolLinterConfig.Condition = {}));
+    let Action;
+    (function (Action) {
+        function isDeclare(value) {
+            return value !== undefined && ['block', 'file', 'public'].includes(value.declare);
+        }
+        Action.isDeclare = isDeclare;
+        function isReport(value) {
+            return value !== undefined && ['inherit', 'hint', 'information', 'warning', 'error'].includes(value.report);
+        }
+        Action.isReport = isReport;
+        function is(v) {
+            if (!v || typeof v !== 'object') {
+                return false;
+            }
+            const value = v;
+            return isDeclare(value) || isReport(value);
+        }
+        Action.is = is;
+    })(Action = SymbolLinterConfig.Action || (SymbolLinterConfig.Action = {}));
+})(SymbolLinterConfig = exports.SymbolLinterConfig || (exports.SymbolLinterConfig = {}));
+/**
+* Config which simulates the default vanilla command system.
+*/
+exports.VanillaConfig = {
+    env: {
+        dataSource: 'GitHub',
+        dependencies: [
+            '@mc-nbtdoc',
+        ],
+        feature: {
+            codeActions: true,
+            colors: true,
+            completions: true,
+            documentHighlighting: true,
+            documentLinks: true,
+            foldingRanges: true,
+            formatting: true,
+            hover: true,
+            inlayHint: {
+                enabledNodes: [
+                    'mcfunction:command_child/unknown',
+                ],
+            },
+            semanticColoring: true,
+            selectionRanges: true,
+            signatures: true,
+        },
+        gameVersion: 'Auto',
+        language: 'Default',
+        permissionLevel: 2,
+        plugins: [],
+        mcmetaSummaryOverrides: {},
+    },
+    format: {
+        blockStateBracketSpacing: { inside: 0 },
+        blockStateCommaSpacing: { before: 0, after: 1 },
+        blockStateEqualSpacing: { before: 0, after: 0 },
+        blockStateTrailingComma: false,
+        eol: 'auto',
+        nbtArrayBracketSpacing: { inside: 0 },
+        nbtArrayCommaSpacing: { before: 0, after: 1 },
+        nbtArraySemicolonSpacing: { after: 1 },
+        nbtArrayTrailingComma: false,
+        nbtByteSuffix: 'b',
+        nbtCompoundBracketSpacing: { inside: 0 },
+        nbtCompoundColonSpacing: { before: 0, after: 1 },
+        nbtCompoundCommaSpacing: { before: 0, after: 1 },
+        nbtCompoundTrailingComma: false,
+        nbtDoubleOmitSuffix: false,
+        nbtDoubleSuffix: 'd',
+        nbtFloatSuffix: 'f',
+        nbtListBracketSpacing: { inside: 0 },
+        nbtListCommaSpacing: { before: 0, after: 1 },
+        nbtListTrailingComma: false,
+        nbtLongSuffix: 'L',
+        nbtShortSuffix: 's',
+        selectorBracketSpacing: { inside: 0 },
+        selectorCommaSpacing: { before: 0, after: 1 },
+        selectorEqualSpacing: { before: 0, after: 0 },
+        selectorTrailingComma: false,
+        timeOmitTickUnit: false,
+    },
+    lint: {
+        blockStateSortKeys: null,
+        nbtCompoundSortKeys: null,
+        selectorSortKeys: null,
+        commandStringQuote: null,
+        nbtKeyQuote: null,
+        nbtPathQuote: null,
+        nbtStringQuote: null,
+        selectorKeyQuote: null,
+        idOmitDefaultNamespace: null,
+        nameOfNbtKey: null,
+        nameOfObjective: null,
+        nameOfScoreHolder: null,
+        nameOfTag: null,
+        nameOfTeam: null,
+        nbtArrayLengthCheck: true,
+        nbtBoolean: null,
+        nbtListLengthCheck: null,
+        nbtTypeCheck: 'loosely',
+        undeclaredSymbol: [
+            {
+                if: [
+                    { category: symbol_1.RegistryCategories, namespace: 'minecraft' },
+                    { category: [...symbol_1.FileCategories, 'bossbar', 'objective', 'team'] },
+                ],
+                then: { report: 'warning' },
+            },
+            {
+                then: { declare: 'block' },
+            },
+        ],
+    },
+    snippet: {
+        executeIfScoreSet: 'execute if score ${1:score_holder} ${2:objective} = ${1:score_holder} ${2:objective} $0',
+        summonAec: 'summon minecraft:area_effect_cloud ~ ~ ~ {Age: -2147483648, Duration: -1, WaitTime: -2147483648, Tags: ["${1:tag}"]}',
+    },
+};
+class ConfigService extends events_1.default {
+    constructor(project) {
+        super();
+        this.project = project;
+        const handler = async ({ uri }) => {
+            if (ConfigService.isConfigFile(uri)) {
+                this.emit('changed', { config: await this.load() });
+            }
+        };
+        project.on('fileCreated', handler);
+        project.on('fileModified', handler);
+        project.on('fileDeleted', handler);
+    }
+    async load() {
+        let ans = exports.VanillaConfig;
+        for (const name of ConfigService.ConfigFileNames) {
+            const uriString = this.project.projectRoot + name;
+            const uri = new common_1.Uri(uriString);
+            try {
+                ans = JSON.parse((0, common_1.bufferToString)(await fs_1.promises.readFile(uri)));
+            }
+            catch (e) {
+                if ((0, common_1.isEnoent)(e)) {
+                    // File doesn't exist.
+                    continue;
+                }
+                this.emit('error', { error: e, uri: uriString });
+            }
+            break;
+        }
+        return this.merge(exports.VanillaConfig, ans);
+    }
+    static isConfigFile(uri) {
+        return ConfigService.ConfigFileNames.some(n => uri.endsWith(`/${n}`));
+    }
+    merge(base, ...overrides) {
+        // FIXME
+        const ans = (0, rfdc_1.default)()(base);
+        for (const override of overrides) {
+            for (const key of ['env', 'format', 'lint', 'snippet']) {
+                ans[key] = { ...ans[key], ...override[key] };
+            }
+        }
+        return ans;
+    }
+}
+exports.ConfigService = ConfigService;
+ConfigService.ConfigFileNames = Object.freeze([
+    'spyglass.json',
+    '.spyglassrc.json',
+]);
+//# sourceMappingURL=Config.js.map