@spyglassmc/core 0.4.43 → 0.4.45

package/lib/service/Config.d.ts

@@ -1,4 +1,4 @@
-import type { ExternalEventEmitter } from '../common/index.js';
+import type { DeepPartial, ExternalEventEmitter } from '../common/index.js';
 import { Arrayable } from '../common/index.js';
 import { ErrorSeverity } from '../source/index.js';
 import type { Project } from './Project.js';
@@ -44,15 +44,6 @@ export interface CustomResourceConfig {
     until?: `${bigint}.${bigint}.${bigint}` | `${bigint}.${bigint}`;
 }
 export interface EnvConfig {
-    /**
-     * Where to download data like `mcmeta` or `vanilla-mcdoc` from (case-insensitive).
-     *
-     * * `GitHub`: Recommended, unless you have trouble connecting to `raw.githubusercontent.com`.
-     * * `fastly`
-     * * `jsDelivr`
-     * * A custom URL, with placeholder variables: `${user}`, `${repo}`, `${tag}`, and `${path}`.
-     */
-    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 `@vanilla-mcdoc`.
@@ -84,7 +75,9 @@ export interface EnvConfig {
         inlayHint: boolean | {
             enabledNodes: string[];
         };
-        semanticColoring: boolean;
+        semanticColoring: boolean | {
+            disabledLanguages?: string[];
+        };
         selectionRanges: boolean;
         signatures: boolean;
     };
@@ -97,10 +90,6 @@ export interface EnvConfig {
      * - 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.
      *
@@ -118,16 +107,6 @@ export interface EnvConfig {
      * May become corrupt after changing game versions, so this is currently disabled by default.
      */
     enableMcdocCaching: boolean;
-    /**
-     * Makes the file-watcher use polling to watch for file changes.
-     * Comes at a performance cost for very large datapacks.
-     *
-     * On Windows, enabling this can fix file-lock issues when Spyglass is running.
-     * See: https://github.com/SpyglassMC/Spyglass/issues/1414
-     *
-     * **You should only consider enabling this for Windows machines.**
-     */
-    useFilePolling: boolean;
 }
 export type LinterSeverity = 'hint' | 'information' | 'warning' | 'error';
 export declare namespace LinterSeverity {
@@ -244,6 +223,15 @@ export declare namespace SymbolLinterConfig {
  * Config which simulates the default vanilla command system.
  */
 export declare const VanillaConfig: Config;
+export type PartialConfig = DeepPartial<Config>;
+export declare namespace PartialConfig {
+    /**
+     * Filters a config for valid editor settings
+     * @param spyglassmcConfiguration An unchecked config, should have the same layout as {@link PartialConfig}
+     * @returns The config, only keeping editor settings that have valid values
+     */
+    function buildConfigFromEditorSettingsSafe(spyglassmcConfiguration: any): PartialConfig;
+}
 type ConfigEvent = {
     config: Config;
 };
@@ -256,6 +244,7 @@ export declare class ConfigService implements ExternalEventEmitter {
     private readonly project;
     private readonly defaultConfig;
     static readonly ConfigFileNames: readonly ["spyglass.json", ".spyglassrc", ".spyglassrc.json"];
+    private currentEditorConfiguration;
     constructor(project: Project, defaultConfig?: Config);
     on(event: 'changed', callbackFn: (data: ConfigEvent) => void): this;
     on(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
@@ -263,6 +252,7 @@ export declare class ConfigService implements ExternalEventEmitter {
     once(event: 'error', callbackFn: (data: ErrorEvent) => void): this;
     emit(event: 'changed', data: ConfigEvent): boolean;
     emit(event: 'error', data: ErrorEvent): boolean;
+    onEditorConfigurationUpdate(editorConfiguration: PartialConfig): Promise<void>;
     load(): Promise<Config>;
     static isConfigFile(this: void, uri: string): boolean;
     static merge(base: Config, ...overrides: any[]): Config;

package/lib/service/Config.js

@@ -106,7 +106,6 @@ export var SymbolLinterConfig;
  */
 export const VanillaConfig = {
     env: {
-        dataSource: 'GitHub',
         dependencies: ['@vanilla-datapack', '@vanilla-resourcepack', '@vanilla-mcdoc'],
         exclude: [
             '.*/**',
@@ -140,12 +139,10 @@ export const VanillaConfig = {
             signatures: true,
         },
         gameVersion: 'Auto',
-        language: 'Default',
         permissionLevel: 2,
         plugins: [],
         mcmetaSummaryOverrides: {},
         enableMcdocCaching: false,
-        useFilePolling: false,
     },
     format: {
         blockStateBracketSpacing: { inside: 0 },
@@ -217,11 +214,94 @@ export const VanillaConfig = {
         summonAec: 'summon minecraft:area_effect_cloud ~ ~ ~ {Age: -2147483648, Duration: -1, WaitTime: -2147483648, Tags: ["${1:tag}"]}',
     },
 };
+export var PartialConfig;
+(function (PartialConfig) {
+    /**
+     * Filters a config for valid editor settings
+     * @param spyglassmcConfiguration An unchecked config, should have the same layout as {@link PartialConfig}
+     * @returns The config, only keeping editor settings that have valid values
+     */
+    function buildConfigFromEditorSettingsSafe(spyglassmcConfiguration) {
+        const result = {};
+        if (!spyglassmcConfiguration || typeof spyglassmcConfiguration !== 'object') {
+            return result;
+        }
+        if (spyglassmcConfiguration.env && typeof spyglassmcConfiguration.env === 'object') {
+            result.env = {};
+            if (typeof spyglassmcConfiguration.env.gameVersion === 'string') {
+                result.env.gameVersion = spyglassmcConfiguration.env.gameVersion;
+            }
+            if (typeof spyglassmcConfiguration.env.enableMcdocCaching === 'boolean') {
+                result.env.enableMcdocCaching = spyglassmcConfiguration.env.enableMcdocCaching;
+            }
+            if (spyglassmcConfiguration.env.feature
+                && typeof spyglassmcConfiguration.env.feature === 'object') {
+                result.env.feature = {};
+                if (typeof spyglassmcConfiguration.env.feature.codeActions === 'boolean') {
+                    result.env.feature.codeActions = spyglassmcConfiguration.env.feature.codeActions;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.colors === 'boolean') {
+                    result.env.feature.colors = spyglassmcConfiguration.env.feature.colors;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.completions === 'boolean') {
+                    result.env.feature.completions = spyglassmcConfiguration.env.feature.completions;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.documentHighlighting === 'boolean') {
+                    result.env.feature.documentHighlighting =
+                        spyglassmcConfiguration.env.feature.documentHighlighting;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.documentLinks === 'boolean') {
+                    result.env.feature.documentLinks = spyglassmcConfiguration.env.feature.documentLinks;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.foldingRanges === 'boolean') {
+                    result.env.feature.foldingRanges = spyglassmcConfiguration.env.feature.foldingRanges;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.formatting === 'boolean') {
+                    result.env.feature.formatting = spyglassmcConfiguration.env.feature.formatting;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.hover === 'boolean') {
+                    result.env.feature.hover = spyglassmcConfiguration.env.feature.hover;
+                }
+                if (spyglassmcConfiguration.env.feature.inlayHint
+                    && typeof spyglassmcConfiguration.env.feature.inlayHint === 'object'
+                    && Array.isArray(spyglassmcConfiguration.env.feature.inlayHint.enabledNodes)) {
+                    result.env.feature.inlayHint = {
+                        enabledNodes: spyglassmcConfiguration.env.feature.inlayHint.enabledNodes
+                            .filter((element) => typeof element === 'string'),
+                    };
+                }
+                if (typeof spyglassmcConfiguration.env.feature.semanticColoring === 'boolean') {
+                    result.env.feature.semanticColoring =
+                        spyglassmcConfiguration.env.feature.semanticColoring;
+                }
+                if (spyglassmcConfiguration.env.feature.semanticColoring
+                    && typeof spyglassmcConfiguration.env.feature.semanticColoring === 'object'
+                    && Array.isArray(spyglassmcConfiguration.env.feature.semanticColoring.disabledLanguages)) {
+                    result.env.feature.semanticColoring = {
+                        disabledLanguages: spyglassmcConfiguration.env.feature.semanticColoring
+                            .disabledLanguages
+                            .filter((element) => typeof element === 'string'),
+                    };
+                }
+                if (typeof spyglassmcConfiguration.env.feature.selectionRanges === 'boolean') {
+                    result.env.feature.selectionRanges =
+                        spyglassmcConfiguration.env.feature.selectionRanges;
+                }
+                if (typeof spyglassmcConfiguration.env.feature.signatures === 'boolean') {
+                    result.env.feature.signatures = spyglassmcConfiguration.env.feature.signatures;
+                }
+            }
+        }
+        return result;
+    }
+    PartialConfig.buildConfigFromEditorSettingsSafe = buildConfigFromEditorSettingsSafe;
+})(PartialConfig || (PartialConfig = {}));
 export class ConfigService {
     project;
     defaultConfig;
     static ConfigFileNames = Object.freeze(['spyglass.json', '.spyglassrc', '.spyglassrc.json']);
     #eventEmitter;
+    currentEditorConfiguration = {};
     constructor(project, defaultConfig = VanillaConfig) {
         this.project = project;
         this.defaultConfig = defaultConfig;
@@ -246,6 +326,10 @@ export class ConfigService {
     emit(event, ...args) {
         return this.#eventEmitter.emit(event, ...args);
     }
+    async onEditorConfigurationUpdate(editorConfiguration) {
+        this.currentEditorConfiguration = editorConfiguration;
+        this.emit('changed', { config: await this.load() });
+    }
     async load() {
         const overrides = [];
         for (const projectRoot of this.project.projectRoots) {
@@ -265,7 +349,7 @@ export class ConfigService {
                 break;
             }
         }
-        return ConfigService.merge(this.defaultConfig, ...overrides);
+        return ConfigService.merge(this.defaultConfig, this.currentEditorConfiguration, ...overrides);
     }
     static isConfigFile(uri) {
         return ConfigService.ConfigFileNames.some((n) => uri.endsWith(`/${n}`));

package/lib/service/FileWatcher.d.ts

@@ -0,0 +1,21 @@
+import type { UriStore } from '../common/index.js';
+/**
+ * A file watcher that reports additions, changes, and deletions of files.
+ * Changes to directories should not be reported.
+ */
+export interface FileWatcher {
+    get watchedFiles(): UriStore;
+    ready(): Promise<void>;
+    on(eventName: 'ready', listener: () => unknown): this;
+    once(eventName: 'ready', listener: () => unknown): this;
+    on(eventName: 'add', listener: (uri: string) => unknown): this;
+    once(eventName: 'add', listener: (uri: string) => unknown): this;
+    on(eventName: 'change', listener: (uri: string) => unknown): this;
+    once(eventName: 'change', listener: (uri: string) => unknown): this;
+    on(eventName: 'unlink', listener: (uri: string) => unknown): this;
+    once(eventName: 'unlink', listener: (uri: string) => unknown): this;
+    on(eventName: 'error', listener: (error: Error) => unknown): this;
+    once(eventName: 'error', listener: (error: Error) => unknown): this;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=FileWatcher.d.ts.map

package/lib/service/FileWatcher.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FileWatcher.js.map

package/lib/service/Project.d.ts

@@ -1,15 +1,16 @@
 import type { TextDocumentContentChangeEvent } from 'vscode-languageserver-textdocument';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import type { ExternalEventEmitter, Externals } from '../common/index.js';
-import { Logger } from '../common/index.js';
+import { Logger, UriStore } from '../common/index.js';
 import type { AstNode } from '../node/index.js';
 import { FileNode } from '../node/index.js';
 import type { PosRangeLanguageError } from '../source/index.js';
 import { SymbolUtil } from '../symbol/index.js';
 import { CacheService } from './CacheService.js';
-import type { Config } from './Config.js';
+import type { Config, PartialConfig } from './Config.js';
 import { FileService } from './FileService.js';
 import type { RootUriString } from './fileUtil.js';
+import type { FileWatcher } from './FileWatcher.js';
 import { MetaRegistry } from './MetaRegistry.js';
 import { ProfilerFactory } from './Profiler.js';
 export type ProjectInitializerContext = Pick<Project, 'cacheRoot' | 'config' | 'externals' | 'isDebugging' | 'logger' | 'meta' | 'projectRoots'>;
@@ -31,6 +32,9 @@ export interface ProjectOptions {
     projectRoots: RootUriString[];
     symbols?: SymbolUtil;
 }
+export interface ProjectReadyOptions {
+    projectRootsWatcher?: FileWatcher;
+}
 export interface DocAndNode {
     doc: TextDocument;
     node: FileNode<AstNode>;
@@ -42,6 +46,10 @@ interface DocumentErrorEvent {
     uri: string;
     version?: number;
 }
+export interface ConfigChangeEvent {
+    oldConfig: Config;
+    newConfig: Config;
+}
 interface FileEvent {
     uri: string;
 }
@@ -96,6 +104,7 @@ export declare class Project implements ExternalEventEmitter {
     #private;
     private static readonly RootSuffix;
     readonly cacheService: CacheService;
+    get watchedFiles(): UriStore;
     get isReady(): boolean;
     config: Config;
     readonly externals: Externals;
@@ -132,7 +141,7 @@ export declare class Project implements ExternalEventEmitter {
     on(event: 'ready', callbackFn: (data: EmptyEvent) => void): this;
     on(event: 'rootsUpdated', callbackFn: (data: RootsEvent) => void): this;
     on(event: 'symbolRegistrarExecuted', callbackFn: (data: SymbolRegistrarEvent) => void): this;
-    on(event: 'configChanged', callbackFn: (data: Config) => void): this;
+    on(event: 'configChanged', callbackFn: (data: ConfigChangeEvent) => void): this;
     once(event: 'documentErrored', callbackFn: (data: DocumentErrorEvent) => void): this;
     once(event: 'documentUpdated', callbackFn: (data: DocumentEvent) => void): this;
     once(event: 'documentRemoved', callbackFn: (data: FileEvent) => void): this;
@@ -140,7 +149,7 @@ export declare class Project implements ExternalEventEmitter {
     once(event: 'ready', callbackFn: (data: EmptyEvent) => void): this;
     once(event: 'rootsUpdated', callbackFn: (data: RootsEvent) => void): this;
     once(event: 'symbolRegistrarExecuted', callbackFn: (data: SymbolRegistrarEvent) => void): this;
-    once(event: 'configChanged', callbackFn: (data: Config) => void): this;
+    once(event: 'configChanged', callbackFn: (data: ConfigChangeEvent) => void): this;
     emit(event: 'documentErrored', data: DocumentErrorEvent): boolean;
     emit(event: 'documentUpdated', data: DocumentEvent): boolean;
     emit(event: 'documentRemoved', data: FileEvent): boolean;
@@ -148,7 +157,7 @@ export declare class Project implements ExternalEventEmitter {
     emit(event: 'ready', data: EmptyEvent): boolean;
     emit(event: 'rootsUpdated', data: RootsEvent): boolean;
     emit(event: 'symbolRegistrarExecuted', data: SymbolRegistrarEvent): boolean;
-    emit(event: 'configChanged', data: Config): boolean;
+    emit(event: 'configChanged', data: ConfigChangeEvent): boolean;
     /**
      * Get all files that are tracked and supported.
      *
@@ -157,8 +166,6 @@ export declare class Project implements ExternalEventEmitter {
      */
     getTrackedFiles(): string[];
     constructor({ cacheRoot, defaultConfig, externals, fs, initializers, isDebugging, logger, profilers, projectRoots, }: ProjectOptions);
-    private setInitPromise;
-    private setReadyPromise;
     /**
      * Load the config file and initialize parsers and processors.
      */
@@ -166,7 +173,7 @@ export declare class Project implements ExternalEventEmitter {
     /**
      * Finish the initial run of parsing, binding, and checking the entire project.
      */
-    ready(): Promise<this>;
+    ready(options?: ProjectReadyOptions): Promise<this>;
     /**
      * Behavior of the `Project` instance is undefined after this function has settled.
      */
@@ -215,6 +222,7 @@ export declare class Project implements ExternalEventEmitter {
     private tryClearingCache;
     private shouldRemove;
     private isOnlyWatched;
+    onEditorConfigurationUpdate(editorConfiguration: PartialConfig): Promise<void>;
 }
 export {};
 //# sourceMappingURL=Project.d.ts.map