@spyglassmc/core 0.4.2 → 0.4.4

package/lib/common/Dev.d.ts

@@ -1,11 +1,11 @@
-export declare const Dev: Readonly<{
-    assertDefined<T>(value: T): asserts value is Exclude<T, undefined>;
-    assertNever(value: never): never;
-    assertTrue(value: boolean, message: string): void;
+export declare namespace Dev {
+    function assertDefined<T>(value: T): asserts value is Exclude<T, undefined>;
+    function assertNever(value: never): never;
+    function assertTrue(value: boolean, message: string): void;
     /**
      * @returns An estimate of the memory taken by the given value, assuming objects are stored as array-like structures instead of dictionaries in the V8 engine.
      */
-    estimateMemoryUsage(value: unknown): number;
-    stringify(value: unknown): string;
-}>;
+    function estimateMemoryUsage(value: unknown): number;
+    function stringify(value: unknown): string;
+}
 //# sourceMappingURL=Dev.d.ts.map

package/lib/common/Dev.js

@@ -1,21 +1,25 @@
-export const Dev = Object.freeze({
-    assertDefined(value) {
+export var Dev;
+(function (Dev) {
+    function assertDefined(value) {
         if (value === undefined) {
             throw new Error(`'${Dev.stringify(value)}' is 'undefined'`);
         }
-    },
-    assertNever(value) {
+    }
+    Dev.assertDefined = assertDefined;
+    function assertNever(value) {
         throw new Error(`'${Dev.stringify(value)}' is not of type 'never'`);
-    },
-    assertTrue(value, message) {
+    }
+    Dev.assertNever = assertNever;
+    function assertTrue(value, message) {
         if (!value) {
             throw new Error(`Assertion failed: ${message}. '${Dev.stringify(value)}' should be true.`);
         }
-    },
+    }
+    Dev.assertTrue = assertTrue;
     /**
      * @returns An estimate of the memory taken by the given value, assuming objects are stored as array-like structures instead of dictionaries in the V8 engine.
      */
-    estimateMemoryUsage(value) {
+    function estimateMemoryUsage(value) {
         const ByteToBits = 8;
         const PointerSize = 8;
         let ans = 0;
@@ -59,8 +63,9 @@ export const Dev = Object.freeze({
             }
         }
         return ans;
-    },
-    stringify(value) {
+    }
+    Dev.estimateMemoryUsage = estimateMemoryUsage;
+    function stringify(value) {
         if (value && typeof value === 'object') {
             try {
                 const seen = new Set();
@@ -88,6 +93,7 @@ export const Dev = Object.freeze({
         else {
             return `${value}`;
         }
-    },
-});
+    }
+    Dev.stringify = stringify;
+})(Dev || (Dev = {}));
 //# sourceMappingURL=Dev.js.map

package/lib/common/ReadonlyProxy.d.ts

@@ -1,9 +1,12 @@
-type Wrap<T> = T extends object ? DeepReadonly<T> : T;
+type DeepReadonlyValue<T> = T extends object ? DeepReadonly<T> : T;
 export type DeepReadonly<T extends object> = {
-    readonly [K in keyof T]: Wrap<T[K]>;
+    readonly [K in keyof T]: DeepReadonlyValue<T[K]>;
 };
-export declare const ReadonlyProxy: Readonly<{
-    create<T extends object>(obj: T): DeepReadonly<T>;
-}>;
+export type ReadWrite<T extends object> = {
+    -readonly [K in keyof T]: T[K];
+};
+export declare namespace ReadonlyProxy {
+    function create<T extends object>(obj: T): DeepReadonly<T>;
+}
 export {};
 //# sourceMappingURL=ReadonlyProxy.d.ts.map

package/lib/common/ReadonlyProxy.js

@@ -1,9 +1,11 @@
 import { emplaceMap, isObject } from './util.js';
-export const ReadonlyProxy = Object.freeze({
-    create(obj) {
+export var ReadonlyProxy;
+(function (ReadonlyProxy) {
+    function create(obj) {
         return new Proxy(obj, new ReadonlyProxyHandler());
-    },
-});
+    }
+    ReadonlyProxy.create = create;
+})(ReadonlyProxy || (ReadonlyProxy = {}));
 class ReadonlyProxyHandler {
     map = new Map();
     get(target, p, receiver) {

package/lib/common/StateProxy.d.ts

@@ -21,15 +21,15 @@ export type StateProxy<T extends object> = {
     [Redo]: () => void;
     [Undo]: () => void;
 };
-export declare const StateProxy: Readonly<{
-    branchOff<T extends object>(proxy: StateProxy<T>): StateProxy<T>;
-    create<T_1 extends object>(obj: T_1): T_1 extends StateProxy<any> ? void & {
+export declare namespace StateProxy {
+    function branchOff<T extends object>(proxy: StateProxy<T>): StateProxy<T>;
+    function create<T extends object>(obj: T): T extends StateProxy<any> ? void & {
         _cannotCreateProxyFromProxy: never;
-    } : StateProxy<T_1>;
-    dereference<T_2 extends object>(value: T_2 | StateProxy<T_2>): T_2;
-    is(obj: any): obj is StateProxy<object>;
-    redoChanges(proxy: StateProxy<object>): void;
-    undoChanges(proxy: StateProxy<object>): void;
-}>;
+    } : StateProxy<T>;
+    function dereference<T extends object>(value: StateProxy<T> | T): T;
+    function is(obj: any): obj is StateProxy<object>;
+    function redoChanges(proxy: StateProxy<object>): void;
+    function undoChanges(proxy: StateProxy<object>): void;
+}
 export {};
 //# sourceMappingURL=StateProxy.d.ts.map

package/lib/common/StateProxy.js

@@ -5,29 +5,36 @@ const Is = Symbol('IsStateProxy');
 const Origin = Symbol('OriginState');
 const Redo = Symbol('RedoStateChanges');
 const Undo = Symbol('UndoStateChanges');
-export const StateProxy = Object.freeze({
-    branchOff(proxy) {
+export var StateProxy;
+(function (StateProxy) {
+    function branchOff(proxy) {
         return proxy[BranchOff]();
-    },
-    create(obj) {
+    }
+    StateProxy.branchOff = branchOff;
+    function create(obj) {
         if (StateProxy.is(obj)) {
             throw new TypeError('Cannot create a proxy over a proxy. You might want to use branchOff instead.');
         }
         return _createStateProxy(obj, new Operations());
-    },
-    dereference(value) {
+    }
+    StateProxy.create = create;
+    function dereference(value) {
         return StateProxy.is(value) ? value[Origin] : value;
-    },
-    is(obj) {
+    }
+    StateProxy.dereference = dereference;
+    function is(obj) {
         return obj?.[Is];
-    },
-    redoChanges(proxy) {
+    }
+    StateProxy.is = is;
+    function redoChanges(proxy) {
         proxy[Redo]();
-    },
-    undoChanges(proxy) {
+    }
+    StateProxy.redoChanges = redoChanges;
+    function undoChanges(proxy) {
         proxy[Undo]();
-    },
-});
+    }
+    StateProxy.undoChanges = undoChanges;
+})(StateProxy || (StateProxy = {}));
 class StateProxyHandler {
     rootOps;
     map = new Map();

package/lib/common/externals/NodeJsExternals.js

@@ -114,8 +114,13 @@ Object.freeze(NodeJsExternals);
  * @returns A {@link fs.PathLike}.
  */
 function toFsPathLike(path) {
+    if (path instanceof Uri) {
+        // Convert WHATWG URL to string so that it will be converted
+        // to Node.js URL by the next if-block.
+        path = path.toString();
+    }
     if (typeof path === 'string' && path.startsWith('file:')) {
-        return new Uri(path);
+        return new url.URL(path);
     }
     return path;
 }
@@ -125,7 +130,7 @@ function toPath(path) {
     }
     return uriToPath(path);
 }
-const uriToPath = (uri) => url.fileURLToPath(uri);
+const uriToPath = (uri) => url.fileURLToPath(uri instanceof Uri ? new url.URL(uri.toString()) : uri);
 const uriFromPath = (path) => url.pathToFileURL(path).toString();
 class ChokidarWatcherWrapper extends EventEmitter {
     #watcher;

package/lib/common/externals/downloader.d.ts

@@ -1,8 +1,8 @@
 type RemoteUriProtocol = 'http:' | 'https:';
 export type RemoteUriString = `${RemoteUriProtocol}${string}`;
-export declare const RemoteUriString: Readonly<{
-    is(value: string): value is `http:${string}` | `https:${string}`;
-}>;
+export declare namespace RemoteUriString {
+    function is(value: string): value is RemoteUriString;
+}
 export interface ExternalDownloaderOptions {
     /**
      * Use an string array to set multiple values to the header.
@@ -16,9 +16,9 @@ export interface ExternalDownloader {
      */
     get(uri: RemoteUriString, options?: ExternalDownloaderOptions): Promise<Uint8Array>;
 }
-export declare const ExternalDownloader: Readonly<{
-    mock(options: ExternalDownloaderMockOptions): ExternalDownloader;
-}>;
+export declare namespace ExternalDownloader {
+    function mock(options: ExternalDownloaderMockOptions): ExternalDownloader;
+}
 interface ExternalDownloaderMockOptions {
     /**
      * A record from URIs to fixture data. The {@link ExternalDownloader.get} only returns a {@link Uint8Array},

package/lib/common/externals/downloader.js

@@ -1,13 +1,17 @@
-export const RemoteUriString = Object.freeze({
-    is(value) {
+export var RemoteUriString;
+(function (RemoteUriString) {
+    function is(value) {
         return value.startsWith('http:') || value.startsWith('https:');
-    },
-});
-export const ExternalDownloader = Object.freeze({
-    mock(options) {
+    }
+    RemoteUriString.is = is;
+})(RemoteUriString || (RemoteUriString = {}));
+export var ExternalDownloader;
+(function (ExternalDownloader) {
+    function mock(options) {
         return new ExternalDownloaderMock(options);
-    },
-});
+    }
+    ExternalDownloader.mock = mock;
+})(ExternalDownloader || (ExternalDownloader = {}));
 class ExternalDownloaderMock {
     options;
     constructor(options) {

package/lib/common/externals/index.d.ts

@@ -74,7 +74,7 @@ export interface ExternalFileSystem {
     }): Promise<void>;
 }
 /**
- * A file file URI string or a URI object.
+ * A file URI string or a URI object.
  */
 export type FsLocation = string | Uri;
 export interface FsWatcher {

package/lib/common/util.d.ts

@@ -1,14 +1,10 @@
 import externalBinarySearch from 'binary-search';
+import { URL } from 'whatwg-url';
 import type { AstNode } from '../node/index.js';
 import type { ProcessorContext } from '../service/index.js';
 import type { Externals } from './externals/index.js';
-import type { DeepReadonly } from './ReadonlyProxy.js';
-export declare const Uri: {
-    new (url: string | URL, base?: string | URL | undefined): URL;
-    prototype: URL;
-    createObjectURL(obj: Blob | MediaSource): string;
-    revokeObjectURL(url: string): void;
-};
+import type { DeepReadonly, ReadWrite } from './ReadonlyProxy.js';
+export declare const Uri: typeof URL;
 export type Uri = URL;
 /**
  * `NodeJS.Timeout` on Node.js and `number` on browser.
@@ -116,17 +112,23 @@ export declare function emplaceMap<K, V>(map: Map<K, V>, key: K, handler: {
 export declare function isObject(val: unknown): val is object;
 export declare function normalizeUri(uri: string): string;
 /**
+ * Return a read-write TARGET type if the INPUT type is read-write, and a
+ * readonly TARGET type if the INPUT type is readonly, and `never` if the INPUT
+ * type is `undefined`.
+ *
+ * It is used in the return type of an AST node
+ * [user-defined type guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
+ *
  * @example
  * ```ts
- * function isCommentNode<T extends DeepReadonly<AstNode> | undefined>(node: T): node is IsHelper<AstNode, CommentNode, T>
- * ```
- */
-export type IsHelper<ROOT extends object, TARGET extends ROOT, INPUT extends DeepReadonly<ROOT> | undefined> = INPUT extends DeepReadonly<ROOT> ? INPUT & DeepReadonly<TARGET> : INPUT & TARGET;
-/**
- * @example
- * ```ts
- * function isCommentNode<T extends DeepReadonly<AstNode> | undefined>(node: T): node is NodeIsHelper<CommentNode, T>
+ * export namespace CommentNode {
+ * 	export function is<T extends DeepReadonly<AstNode> | undefined>(
+ * 		obj: T,
+ * 	): obj is InheritReadonly<CommentNode, T> {
+ * 		return (obj as CommentNode | undefined)?.type === 'comment'
+ * 	}
+ * }
  * ```
  */
-export type NodeIsHelper<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = IsHelper<AstNode, TARGET, INPUT>;
+export type InheritReadonly<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = INPUT & (INPUT extends ReadWrite<AstNode> ? TARGET : DeepReadonly<TARGET>);
 //# sourceMappingURL=util.d.ts.map

package/lib/common/util.js

@@ -1,5 +1,16 @@
 import externalBinarySearch from 'binary-search';
 import rfdc from 'rfdc';
+import { URL } from 'whatwg-url';
+// Spyglass uses the URL class provided by the
+// [spec](https://url.spec.whatwg.org/)-compliant `whatwg-url` package instead
+// of the broken one shipped with browsers that do not parse non-special scheme
+// URLs with hosts properly.
+//
+// * [Chromium bug](https://issues.chromium.org/issues/40587286)
+// * [FireFox bug](https://bugzilla.mozilla.org/show_bug.cgi?id=1374505)
+//
+// We use the name "URI" instead of "URL" when possible, since it is what
+// LSP has chosen to use for the string that uniquely identifies a file.
 export const Uri = URL;
 /**
  * @param getKey A function that takes the actual arguments being passed into the decorated method, and returns anything.

package/lib/node/CommentNode.d.ts

@@ -1,4 +1,4 @@
-import type { DeepReadonly, NodeIsHelper } from '../common/index.js';
+import type { DeepReadonly, InheritReadonly } from '../common/index.js';
 import type { AstNode } from './AstNode.js';
 export interface CommentNode extends AstNode {
     readonly type: 'comment';
@@ -7,7 +7,7 @@ export interface CommentNode extends AstNode {
      */
     comment: string;
 }
-export declare const CommentNode: Readonly<{
-    is<T extends DeepReadonly<AstNode> | undefined>(obj: T): obj is NodeIsHelper<CommentNode, T>;
-}>;
+export declare namespace CommentNode {
+    function is<T extends DeepReadonly<AstNode> | undefined>(obj: T): obj is InheritReadonly<CommentNode, T>;
+}
 //# sourceMappingURL=CommentNode.d.ts.map

package/lib/node/CommentNode.js

@@ -1,6 +1,8 @@
-export const CommentNode = Object.freeze({
-    is(obj) {
+export var CommentNode;
+(function (CommentNode) {
+    function is(obj) {
         return obj?.type === 'comment';
-    },
-});
+    }
+    CommentNode.is = is;
+})(CommentNode || (CommentNode = {}));
 //# sourceMappingURL=CommentNode.js.map

package/lib/parser/resourceLocation.js

@@ -96,7 +96,7 @@ export function resourceLocation(options) {
                 ctx.err.report(localize('parser.resource-location.illegal', arrayToMessage(illegalChars, true, 'and')), ans);
             }
             if (ans.isTag && !options.allowTag) {
-                ctx.err.report(localize('parser.resource-location.tag-diallowed'), ans);
+                ctx.err.report(localize('parser.resource-location.tag-disallowed'), ans);
             }
             if (!ans.namespace && options.isPredicate) {
                 ctx.err.report(localize('parser.resource-location.namespace-expected'), ans);

package/lib/parser/util.d.ts

@@ -149,5 +149,9 @@ export declare function stopBefore<N extends Returnable>(parser: Parser<N>, ...t
 export declare function acceptOnly<N extends Returnable>(parser: InfallibleParser<N>, ...characters: (string | readonly string[])[]): InfallibleParser<N>;
 export declare function acceptOnly<N extends Returnable>(parser: Parser<N>, ...characters: (string | readonly string[])[]): Parser<N>;
 export declare function acceptIf<P extends Parser<AstNode>>(parser: P, predicate: (this: void, char: string) => boolean): P extends InfallibleParser<infer N> ? InfallibleParser<N> : P extends Parser<infer N> ? Parser<N> : never;
+/**
+ * @returns A parser that dumps any parser errors after it finishes parsing.
+ */
+export declare function dumpErrors<P extends Parser<AstNode>>(parser: P): P;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/lib/parser/util.js

@@ -243,4 +243,14 @@ export function acceptIf(parser, predicate) {
         return ans;
     });
 }
+/**
+ * @returns A parser that dumps any parser errors after it finishes parsing.
+ */
+export function dumpErrors(parser) {
+    return ((src, ctx) => {
+        const ans = parser(src, ctx);
+        ctx.err.dump();
+        return ans;
+    });
+}
 //# sourceMappingURL=util.js.map

package/lib/processor/InlayHintProvider.d.ts

@@ -2,8 +2,10 @@ import type { DeepReadonly } from '../common/index.js';
 import type { AstNode } from '../node/index.js';
 import type { ProcessorContext } from '../service/index.js';
 export interface InlayHint {
+    label: string;
     offset: number;
-    text: string;
+    paddingLeft?: boolean;
+    paddingRight?: boolean;
 }
 export type InlayHintProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ProcessorContext) => readonly InlayHint[];
 //# sourceMappingURL=InlayHintProvider.d.ts.map

package/lib/processor/binder/Binder.d.ts

@@ -8,19 +8,19 @@ export interface SyncBinderInitializer<N extends AstNode> {
 export interface SyncBinder<N extends AstNode> extends SyncBinderInitializer<N> {
     [IsAsync]?: never;
 }
-export declare const SyncBinder: Readonly<{
-    create<N extends AstNode>(binder: SyncBinderInitializer<N>): SyncBinder<N>;
-    is(binder: Binder<any>): binder is SyncBinder<any>;
-}>;
+export declare namespace SyncBinder {
+    function create<N extends AstNode>(binder: SyncBinderInitializer<N>): SyncBinder<N>;
+    function is(binder: Binder<any>): binder is SyncBinder<any>;
+}
 interface AsyncBinderInitializer<N extends AstNode> {
     (node: N, ctx: BinderContext): Promise<void>;
 }
 export interface AsyncBinder<N extends AstNode> extends AsyncBinderInitializer<N> {
     [IsAsync]: true;
 }
-export declare const AsyncBinder: Readonly<{
-    create<N extends AstNode>(binder: AsyncBinderInitializer<N>): AsyncBinder<N>;
-    is(binder: Binder<any>): binder is AsyncBinder<any>;
-}>;
+export declare namespace AsyncBinder {
+    function create<N extends AstNode>(binder: AsyncBinderInitializer<N>): AsyncBinder<N>;
+    function is(binder: Binder<any>): binder is AsyncBinder<any>;
+}
 export {};
 //# sourceMappingURL=Binder.d.ts.map

package/lib/processor/binder/Binder.js

@@ -1,18 +1,24 @@
 const IsAsync = Symbol('IsAsyncBinder');
-export const SyncBinder = Object.freeze({
-    create(binder) {
+export var SyncBinder;
+(function (SyncBinder) {
+    function create(binder) {
         return binder;
-    },
-    is(binder) {
+    }
+    SyncBinder.create = create;
+    function is(binder) {
         return !binder[IsAsync];
-    },
-});
-export const AsyncBinder = Object.freeze({
-    create(binder) {
+    }
+    SyncBinder.is = is;
+})(SyncBinder || (SyncBinder = {}));
+export var AsyncBinder;
+(function (AsyncBinder) {
+    function create(binder) {
         return Object.assign(binder, { [IsAsync]: true });
-    },
-    is(binder) {
+    }
+    AsyncBinder.create = create;
+    function is(binder) {
         return binder[IsAsync];
-    },
-});
+    }
+    AsyncBinder.is = is;
+})(AsyncBinder || (AsyncBinder = {}));
 //# sourceMappingURL=Binder.js.map

package/lib/service/Config.js

@@ -117,7 +117,10 @@ export var SymbolLinterConfig;
 export const VanillaConfig = {
     env: {
         dataSource: 'GitHub',
-        dependencies: ['@vanilla-mcdoc'],
+        dependencies: [
+            '@vanilla-datapack',
+            '@vanilla-mcdoc',
+        ],
         feature: {
             codeActions: true,
             colors: true,
@@ -128,7 +131,16 @@ export const VanillaConfig = {
             formatting: true,
             hover: true,
             inlayHint: {
-                enabledNodes: ['mcfunction:command_child/unknown'],
+                enabledNodes: [
+                    'boolean',
+                    'double',
+                    'float',
+                    'integer',
+                    'long',
+                    'mcfunction:coordinate',
+                    'mcfunction:vector',
+                    'mcfunction:command_child/unknown',
+                ],
             },
             semanticColoring: true,
             selectionRanges: true,
@@ -208,7 +220,7 @@ export const VanillaConfig = {
         summonAec: 'summon minecraft:area_effect_cloud ~ ~ ~ {Age: -2147483648, Duration: -1, WaitTime: -2147483648, Tags: ["${1:tag}"]}',
     },
 };
-class ConfigService {
+export class ConfigService {
     project;
     defaultConfig;
     static ConfigFileNames = Object.freeze([
@@ -272,5 +284,4 @@ class ConfigService {
         return ans;
     }
 }
-export { ConfigService };
 //# sourceMappingURL=Config.js.map

package/lib/service/FileService.d.ts

@@ -100,7 +100,7 @@ export declare class ArchiveUriSupporter implements UriProtocolSupporter {
     private static readonly SupportedArchiveExtnames;
     readonly protocol = "archive:";
     /**
-     * @param entries A map from archive URIs to unzipped entries.
+     * @param entries A map from archive names to unzipped entries.
      */
     private constructor();
     hash(uri: string): Promise<string>;
@@ -116,7 +116,7 @@ export declare class ArchiveUriSupporter implements UriProtocolSupporter {
      * @throws When `uri` has the wrong protocol or hostname.
      */
     private static decodeUri;
-    static create(dependencies: readonly Dependency[], externals: Externals, logger: Logger, checksums: Record<RootUriString, string>): Promise<ArchiveUriSupporter>;
+    static create(dependencies: readonly Dependency[], externals: Externals, logger: Logger): Promise<ArchiveUriSupporter>;
 }
 export {};
 //# sourceMappingURL=FileService.d.ts.map