@spyglassmc/core 0.1.1 → 0.3.0

package/lib/service/Downloader.js

@@ -1,64 +1,44 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _Downloader_memoryCache;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LowLevelDownloader = exports.Downloader = exports.RemoteUriString = void 0;
-const follow_redirects_1 = require("follow-redirects");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const perf_hooks_1 = require("perf_hooks");
-const common_1 = require("../common");
-const fileUtil_1 = require("./fileUtil");
-var RemoteUriString;
-(function (RemoteUriString) {
-    function getProtocol(uri) {
-        return uri.slice(0, uri.indexOf(':') + 1);
-    }
-    RemoteUriString.getProtocol = getProtocol;
-})(RemoteUriString = exports.RemoteUriString || (exports.RemoteUriString = {}));
-class Downloader {
-    constructor(cacheRoot, logger, lld = LowLevelDownloader.create()) {
+import { bufferToString, Uri } from '../common/index.js';
+import { fileUtil } from './fileUtil.js';
+export class Downloader {
+    cacheRoot;
+    externals;
+    logger;
+    #memoryCache = new Map();
+    constructor(cacheRoot, externals, logger) {
         this.cacheRoot = cacheRoot;
+        this.externals = externals;
         this.logger = logger;
-        this.lld = lld;
-        _Downloader_memoryCache.set(this, new Map());
     }
     async download(job, out = {}) {
         const { id, cache, uri, options, transformer, ttl } = job;
-        if (ttl && __classPrivateFieldGet(this, _Downloader_memoryCache, "f").has(uri)) {
-            const { buffer, time } = __classPrivateFieldGet(this, _Downloader_memoryCache, "f").get(uri);
-            if (time <= perf_hooks_1.performance.now() + ttl) {
+        if (ttl && this.#memoryCache.has(uri)) {
+            const { buffer, time } = this.#memoryCache.get(uri);
+            if (time <= performance.now() + ttl) {
                 this.logger.info(`[Downloader] [${id}] Skipped thanks to valid cache in memory`);
                 return await transformer(buffer);
             }
             else {
-                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").delete(uri);
+                this.#memoryCache.delete(uri);
             }
         }
         let checksum;
-        let cachePath;
-        let cacheChecksumPath;
+        let cacheUri;
+        let cacheChecksumUri;
         if (cache) {
             const { checksumJob, checksumExtension } = cache;
-            out.cachePath = cachePath = path_1.default.join(this.cacheRoot, 'downloader', id);
-            cacheChecksumPath = path_1.default.join(this.cacheRoot, 'downloader', id + checksumExtension);
+            out.cacheUri = cacheUri = new Uri(`downloader/${id}`, this.cacheRoot).toString();
+            cacheChecksumUri = new Uri(`downloader/${id}${checksumExtension}`, this.cacheRoot).toString();
             try {
                 out.checksum = checksum = await this.download({ ...checksumJob, id: id + checksumExtension });
                 try {
-                    const cacheChecksum = (0, common_1.bufferToString)(await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cacheChecksumPath)))
+                    const cacheChecksum = bufferToString(await fileUtil.readFile(this.externals, cacheChecksumUri))
                         .slice(0, -1); // Remove ending newline
                     if (checksum === cacheChecksum) {
                         try {
-                            const cachedBuffer = await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cachePath));
+                            const cachedBuffer = await fileUtil.readFile(this.externals, cacheUri);
                             if (ttl) {
-                                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").set(uri, { buffer: cachedBuffer, time: perf_hooks_1.performance.now() });
+                                this.#memoryCache.set(uri, { buffer: cachedBuffer, time: performance.now() });
                             }
                             const deserializer = cache.deserializer ?? (b => b);
                             const ans = await transformer(deserializer(cachedBuffer));
@@ -66,23 +46,23 @@ class Downloader {
                             return ans;
                         }
                         catch (e) {
-                            this.logger.error(`[Downloader] [${id}] Loading cached file “${cachePath}”`, e);
-                            if ((0, common_1.isEnoent)(e)) {
+                            this.logger.error(`[Downloader] [${id}] Loading cached file “${cacheUri}”`, e);
+                            if (this.externals.error.isKind(e, 'ENOENT')) {
                                 // Cache checksum exists, but cached file doesn't.
                                 // Remove the invalid cache checksum.
                                 try {
-                                    await fs_1.promises.unlink(cacheChecksumPath);
+                                    await this.externals.fs.unlink(cacheChecksumUri);
                                 }
                                 catch (e) {
-                                    this.logger.error(`[Downloader] [${id}] Removing invalid cache checksum “${cacheChecksumPath}”`, e);
+                                    this.logger.error(`[Downloader] [${id}] Removing invalid cache checksum “${cacheChecksumUri}”`, e);
                                 }
                             }
                         }
                     }
                 }
                 catch (e) {
-                    if (!(0, common_1.isEnoent)(e)) {
-                        this.logger.error(`[Downloader] [${id}] Loading cache checksum “${cacheChecksumPath}”`, e);
+                    if (!this.externals.error.isKind(e, 'ENOENT')) {
+                        this.logger.error(`[Downloader] [${id}] Loading cache checksum “${cacheChecksumUri}”`, e);
                     }
                 }
             }
@@ -91,25 +71,25 @@ class Downloader {
             }
         }
         try {
-            const buffer = await this.lld.get(uri, options);
+            const buffer = await this.externals.downloader.get(uri, options);
             if (ttl) {
-                __classPrivateFieldGet(this, _Downloader_memoryCache, "f").set(uri, { buffer, time: perf_hooks_1.performance.now() });
+                this.#memoryCache.set(uri, { buffer, time: performance.now() });
             }
-            if (cache && cachePath && cacheChecksumPath) {
+            if (cache && cacheUri && cacheChecksumUri) {
                 if (checksum) {
                     try {
-                        await fileUtil_1.fileUtil.writeFile(fileUtil_1.fileUtil.pathToFileUri(cacheChecksumPath), `${checksum}\n`);
+                        await fileUtil.writeFile(this.externals, cacheChecksumUri, `${checksum}\n`);
                     }
                     catch (e) {
-                        this.logger.error(`[Downloader] [${id}] Saving cache checksum “${cacheChecksumPath}”`, e);
+                        this.logger.error(`[Downloader] [${id}] Saving cache checksum “${cacheChecksumUri}”`, e);
                     }
                 }
                 try {
                     const serializer = cache.serializer ?? (b => b);
-                    await fileUtil_1.fileUtil.writeFile(fileUtil_1.fileUtil.pathToFileUri(cachePath), serializer(buffer));
+                    await fileUtil.writeFile(this.externals, cacheUri, serializer(buffer));
                 }
                 catch (e) {
-                    this.logger.error(`[Downloader] [${id}] Caching file “${cachePath}”`, e);
+                    this.logger.error(`[Downloader] [${id}] Caching file “${cacheUri}”`, e);
                 }
             }
             this.logger.info(`[Downloader] [${id}] Downloaded from “${uri}”`);
@@ -117,69 +97,20 @@ class Downloader {
         }
         catch (e) {
             this.logger.error(`[Downloader] [${id}] Downloading “${uri}”`, e);
-            if (cache && cachePath) {
+            if (cache && cacheUri) {
                 try {
-                    const cachedBuffer = await fileUtil_1.fileUtil.readFile(fileUtil_1.fileUtil.pathToFileUri(cachePath));
+                    const cachedBuffer = await fileUtil.readFile(this.externals, cacheUri);
                     const deserializer = cache.deserializer ?? (b => b);
                     const ans = await transformer(deserializer(cachedBuffer));
-                    this.logger.warn(`[Downloader] [${id}] Fell back to cached file “${cachePath}”`);
+                    this.logger.warn(`[Downloader] [${id}] Fell back to cached file “${cacheUri}”`);
                     return ans;
                 }
                 catch (e) {
-                    this.logger.error(`[Downloader] [${id}] Fallback: loading cached file “${cachePath}”`, e);
+                    this.logger.error(`[Downloader] [${id}] Fallback: loading cached file “${cacheUri}”`, e);
                 }
             }
         }
         return undefined;
     }
 }
-exports.Downloader = Downloader;
-_Downloader_memoryCache = new WeakMap();
-var LowLevelDownloader;
-(function (LowLevelDownloader) {
-    function create() {
-        return new LowLevelDownloaderImpl();
-    }
-    LowLevelDownloader.create = create;
-    function mock(options) {
-        return new LowLevelDownloaderMock(options);
-    }
-    LowLevelDownloader.mock = mock;
-})(LowLevelDownloader = exports.LowLevelDownloader || (exports.LowLevelDownloader = {}));
-class LowLevelDownloaderImpl {
-    get(uri, options = {}) {
-        const protocol = RemoteUriString.getProtocol(uri);
-        return new Promise((resolve, reject) => {
-            const backend = protocol === 'http:' ? follow_redirects_1.http : follow_redirects_1.https;
-            backend.get(uri, options, (res) => {
-                if (res.statusCode !== 200) {
-                    reject(new Error(`Status code ${res.statusCode}: ${res.statusMessage}`));
-                }
-                else {
-                    resolve((0, common_1.promisifyAsyncIterable)(res, chunks => Buffer.concat(chunks)));
-                }
-            });
-        });
-    }
-}
-class LowLevelDownloaderMock {
-    constructor(options) {
-        this.options = options;
-    }
-    async get(uri) {
-        if (!this.options.fixtures[uri]) {
-            throw new Error(`404 not found: ${uri}`);
-        }
-        const fixture = this.options.fixtures[uri];
-        if (Buffer.isBuffer(fixture)) {
-            return fixture;
-        }
-        else if (typeof fixture === 'string') {
-            return Buffer.from(fixture, 'utf-8');
-        }
-        else {
-            return Buffer.from(JSON.stringify(fixture), 'utf-8');
-        }
-    }
-}
 //# sourceMappingURL=Downloader.js.map

package/lib/service/ErrorReporter.d.ts

@@ -1,5 +1,5 @@
-import type { LanguageErrorInfo, RangeLike } from '../source';
-import { ErrorSeverity, LanguageError } from '../source';
+import type { LanguageErrorInfo, RangeLike } from '../source/index.js';
+import { ErrorSeverity, LanguageError } from '../source/index.js';
 export declare class ErrorReporter {
     errors: LanguageError[];
     constructor();

package/lib/service/ErrorReporter.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinterErrorReporter = exports.ErrorReporter = void 0;
-const locales_1 = require("@spyglassmc/locales");
-const source_1 = require("../source");
-class ErrorReporter {
-    constructor() {
-        this.errors = [];
-    }
+import { localize } from '@spyglassmc/locales';
+import { LanguageError, Range } from '../source/index.js';
+export class ErrorReporter {
+    errors = [];
+    constructor() { }
     /**
      * Reports a new error.
      */
-    report(message, range, severity = 3 /* Error */, info) {
-        this.errors.push(source_1.LanguageError.create(message, source_1.Range.get(range), severity, info));
+    report(message, range, severity = 3 /* ErrorSeverity.Error */, info) {
+        this.errors.push(LanguageError.create(message, Range.get(range), severity, info));
     }
     /**
      * @returns All reported errors, and then clears the error stack.
@@ -29,15 +25,16 @@ class ErrorReporter {
         this.errors.push(...reporter.errors);
     }
 }
-exports.ErrorReporter = ErrorReporter;
-class LinterErrorReporter extends ErrorReporter {
+export class LinterErrorReporter extends ErrorReporter {
+    ruleName;
+    ruleSeverity;
     constructor(ruleName, ruleSeverity) {
         super();
         this.ruleName = ruleName;
         this.ruleSeverity = ruleSeverity;
     }
     lint(message, range, info, severityOverride) {
-        return this.report((0, locales_1.localize)('linter.diagnostic-message-wrapper', message, this.ruleName), range, severityOverride ?? this.ruleSeverity, info);
+        return this.report(localize('linter.diagnostic-message-wrapper', message, this.ruleName), range, severityOverride ?? this.ruleSeverity, info);
     }
     static fromErrorReporter(reporter, ruleName, ruleSeverity) {
         const ans = new LinterErrorReporter(ruleName, ruleSeverity);
@@ -45,5 +42,4 @@ class LinterErrorReporter extends ErrorReporter {
         return ans;
     }
 }
-exports.LinterErrorReporter = LinterErrorReporter;
 //# sourceMappingURL=ErrorReporter.js.map

package/lib/service/FileService.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
-import type { Dependency } from './Dependency';
-import type { RootUriString } from './fileUtil';
-import type { Logger } from './Logger';
+import type { Externals, Logger } from '../common/index.js';
+import type { Dependency } from './Dependency.js';
+import type { RootUriString } from './fileUtil.js';
 export interface UriProtocolSupporter {
     /**
      * @throws
@@ -16,7 +15,7 @@ export interface UriProtocolSupporter {
      * @returns The content of the file at `uri`.
      * @throws If the URI doesn't exist in the file system.
      */
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     listFiles(): Iterable<string>;
     /**
      * Each URI in this array must end with a slash (`/`).
@@ -37,12 +36,29 @@ export interface FileService extends UriProtocolSupporter {
      * Unregister the supported associated with `protocol`. Nothing happens if the `protocol` isn't supported.
      */
     unregister(protocol: Protocol): void;
+    /**
+     * Map the item at `uri` to physical disk.
+     *
+     * @returns The `file:` URI of the mapped file, or `undefined` if it cannot be mapped.
+     */
+    mapToDisk(uri: string): Promise<string | undefined>;
+    /**
+     * Map the item at `uri` from physical disk back to a (virtual) URI used by Spyglass internally.
+     */
+    mapFromDisk(uri: string): string;
 }
 export declare namespace FileService {
-    function create(): FileService;
+    function create(externals: Externals, cacheRoot: RootUriString): FileService;
 }
 export declare class FileServiceImpl implements FileService {
+    private readonly externals;
+    private readonly virtualUrisRoot?;
     private readonly supporters;
+    /**
+     * A two-way map from mapped physical URIs to virtual URIs.
+     */
+    private readonly map;
+    constructor(externals: Externals, virtualUrisRoot?: `${string}/` | undefined);
     register(protocol: Protocol, supporter: UriProtocolSupporter, force?: boolean): void;
     unregister(protocol: Protocol): void;
     /**
@@ -58,39 +74,49 @@ export declare class FileServiceImpl implements FileService {
     /**
      * @throws
      */
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     listFiles(): Generator<string, void, undefined>;
     listRoots(): Generator<`${string}/`, void, undefined>;
+    mapToDisk(virtualUri: string): Promise<string | undefined>;
+    mapFromDisk(mappedUri: string): string;
 }
 export declare class FileUriSupporter implements UriProtocolSupporter {
+    private readonly externals;
     private readonly roots;
     private readonly files;
     readonly protocol = "file:";
     private constructor();
     hash(uri: string): Promise<string>;
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     listFiles(): Generator<string, void, undefined>;
     listRoots(): `${string}/`[];
-    private static rootUriToGlob;
-    static create(dependencies: readonly Dependency[], logger: Logger): Promise<FileUriSupporter>;
+    mapToDisk(uri: string): Promise<string | undefined>;
+    static create(dependencies: readonly Dependency[], externals: Externals, logger: Logger): Promise<FileUriSupporter>;
 }
-export declare class SpyglassUriSupporter implements UriProtocolSupporter {
+export declare class ArchiveUriSupporter implements UriProtocolSupporter {
+    private readonly externals;
     private readonly entries;
-    readonly protocol = "spyglassmc:";
+    static readonly Protocol = "archive:";
     private static readonly SupportedArchiveExtnames;
+    readonly protocol = "archive:";
     /**
      * @param entries A map from archive URIs to unzipped entries.
      */
     private constructor();
     hash(uri: string): Promise<string>;
-    readFile(uri: string): Promise<Buffer>;
+    readFile(uri: string): Promise<Uint8Array>;
     /**
      * @throws
      */
     private getDataInArchive;
     listFiles(): Generator<string, void, unknown>;
     listRoots(): Generator<`${string}/`, void, unknown>;
-    static create(dependencies: readonly Dependency[], logger: Logger, checksums: Record<RootUriString, string>): Promise<SpyglassUriSupporter>;
+    private static getUri;
+    /**
+     * @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>;
 }
 export {};
 //# sourceMappingURL=FileService.d.ts.map