@spyglassmc/core 0.4.2 → 0.4.3

package/lib/service/FileService.js

@@ -79,6 +79,17 @@ export class FileServiceImpl {
             if (mappedUri === undefined) {
                 mappedUri = `${this.virtualUrisRoot}${await this.externals.crypto
                     .getSha1(virtualUri)}/${fileUtil.basename(virtualUri)}`;
+                // Delete old mapped file if it exists. This makes sure the
+                // readonly permission on the file is not removed by it being
+                // overwritten.
+                try {
+                    await fileUtil.unlink(this.externals, mappedUri);
+                }
+                catch (e) {
+                    if (!this.externals.error.isKind(e, 'ENOENT')) {
+                        throw e;
+                    }
+                }
                 const buffer = await this.readFile(virtualUri);
                 await fileUtil.writeFile(this.externals, mappedUri, buffer, 0o444);
                 this.map.set(mappedUri, virtualUri);
@@ -148,7 +159,7 @@ export class FileUriSupporter {
 // 	return uri.protocol === Protocol && uri.hostname === Hostname
 // }
 // }
-class ArchiveUriSupporter {
+export class ArchiveUriSupporter {
     externals;
     entries;
     static Protocol = 'archive:';
@@ -160,58 +171,58 @@ class ArchiveUriSupporter {
     ];
     protocol = ArchiveUriSupporter.Protocol;
     /**
-     * @param entries A map from archive URIs to unzipped entries.
+     * @param entries A map from archive names to unzipped entries.
      */
     constructor(externals, entries) {
         this.externals = externals;
         this.entries = entries;
     }
     async hash(uri) {
-        const { archiveUri, pathInArchive } = ArchiveUriSupporter.decodeUri(new Uri(uri));
+        const { archiveName, pathInArchive } = ArchiveUriSupporter.decodeUri(new Uri(uri));
         if (!pathInArchive) {
             // Hash the archive itself.
-            return hashFile(this.externals, archiveUri);
+            return hashFile(this.externals, archiveName);
         }
         else {
             // Hash the corresponding file.
-            return this.externals.crypto.getSha1(this.getDataInArchive(archiveUri, pathInArchive));
+            return this.externals.crypto.getSha1(this.getDataInArchive(archiveName, pathInArchive));
         }
     }
     async readFile(uri) {
-        const { archiveUri, pathInArchive } = ArchiveUriSupporter.decodeUri(new Uri(uri));
-        return this.getDataInArchive(archiveUri, pathInArchive);
+        const { archiveName, pathInArchive } = ArchiveUriSupporter.decodeUri(new Uri(uri));
+        return this.getDataInArchive(archiveName, pathInArchive);
     }
     /**
      * @throws
      */
-    getDataInArchive(archiveUri, pathInArchive) {
-        const entries = this.entries.get(archiveUri);
+    getDataInArchive(archiveName, pathInArchive) {
+        const entries = this.entries.get(archiveName);
         if (!entries) {
-            throw new Error(`Archive “${archiveUri}” has not been loaded into the memory`);
+            throw new Error(`Archive “${archiveName}” has not been loaded into the memory`);
         }
         const entry = entries.get(pathInArchive);
         if (!entry) {
-            throw new Error(`Path “${pathInArchive}” does not exist in archive “${archiveUri}”`);
+            throw new Error(`Path “${pathInArchive}” does not exist in archive “${archiveName}”`);
         }
         if (entry.type !== 'file') {
-            throw new Error(`Path “${pathInArchive}” in archive “${archiveUri}” is not a file`);
+            throw new Error(`Path “${pathInArchive}” in archive “${archiveName}” is not a file`);
         }
         return entry.data;
     }
     *listFiles() {
-        for (const [archiveUri, files] of this.entries.entries()) {
+        for (const [archiveName, files] of this.entries.entries()) {
             for (const file of files.values()) {
-                yield ArchiveUriSupporter.getUri(archiveUri, file.path);
+                yield ArchiveUriSupporter.getUri(archiveName, file.path);
             }
         }
     }
     *listRoots() {
-        for (const archiveUri of this.entries.keys()) {
-            yield ArchiveUriSupporter.getUri(archiveUri);
+        for (const archiveName of this.entries.keys()) {
+            yield ArchiveUriSupporter.getUri(archiveName);
         }
     }
-    static getUri(archiveUri, pathInArchive = '') {
-        return `${ArchiveUriSupporter.Protocol}${encodeURIComponent(archiveUri)}?path=${encodeURIComponent(pathInArchive.replace(/\\/g, '/'))}`;
+    static getUri(archiveName, pathInArchive = '') {
+        return `${ArchiveUriSupporter.Protocol}//${archiveName}/${pathInArchive.replace(/\\/g, '/')}`;
     }
     /**
      * @throws When `uri` has the wrong protocol or hostname.
@@ -220,38 +231,32 @@ class ArchiveUriSupporter {
         if (uri.protocol !== ArchiveUriSupporter.Protocol) {
             throw new Error(`Expected protocol “${ArchiveUriSupporter.Protocol}” in “${uri}”`);
         }
-        const path = uri.searchParams.get('path');
+        const path = uri.pathname;
         if (!path) {
             throw new Error(`Missing path in archive uri “${uri.toString()}”`);
         }
         return {
-            archiveUri: decodeURIComponent(uri.pathname),
+            archiveName: uri.host,
             pathInArchive: path.charAt(0) === '/' ? path.slice(1) : path,
         };
     }
-    static async create(dependencies, externals, logger, checksums) {
+    static async create(dependencies, externals, logger) {
         const entries = new Map();
         for (const { uri, info } of dependencies) {
             try {
                 if (uri.startsWith('file:') &&
                     ArchiveUriSupporter.SupportedArchiveExtnames.some((ext) => uri.endsWith(ext)) &&
                     (await externals.fs.stat(uri)).isFile()) {
-                    const rootUri = ArchiveUriSupporter.getUri(uri);
-                    const cachedChecksum = checksums[rootUri];
-                    if (cachedChecksum !== undefined) {
-                        const checksum = await hashFile(externals, uri);
-                        if (cachedChecksum === checksum) {
-                            // The dependency has not changed since last cache.
-                            logger.info(`[SpyglassUriSupporter#create] Skipped decompressing “${uri}” thanks to cache ${checksum}`);
-                            continue;
-                        }
+                    const archiveName = fileUtil.basename(uri);
+                    if (entries.has(archiveName)) {
+                        throw new Error(`A different URI with ${archiveName} already exists`);
                     }
                     const files = await externals.archive.decompressBall(await externals.fs.readFile(uri), {
                         stripLevel: typeof info?.startDepth === 'number'
                             ? info.startDepth
                             : 0,
                     });
-                    entries.set(uri, new Map(files.map((f) => [f.path.replace(/\\/g, '/'), f])));
+                    entries.set(archiveName, new Map(files.map((f) => [f.path.replace(/\\/g, '/'), f])));
                 }
             }
             catch (e) {
@@ -261,7 +266,6 @@ class ArchiveUriSupporter {
         return new ArchiveUriSupporter(externals, entries);
     }
 }
-export { ArchiveUriSupporter };
 async function hashFile(externals, uri) {
     return externals.crypto.getSha1(await externals.fs.readFile(uri));
 }

package/lib/service/Project.js

@@ -21,7 +21,7 @@ import { ArchiveUriSupporter, FileService, FileUriSupporter, } from './FileServi
 import { fileUtil } from './fileUtil.js';
 import { MetaRegistry } from './MetaRegistry.js';
 import { ProfilerFactory } from './Profiler.js';
-const CacheAutoSaveInterval = 600000; // 10 Minutes.
+const CacheAutoSaveInterval = 600_000; // 10 Minutes.
 /* istanbul ignore next */
 /**
  * Manage all tracked documents and errors.
@@ -60,7 +60,7 @@ const CacheAutoSaveInterval = 600000; // 10 Minutes.
  *
  * After the READY process is complete, editing text documents as signaled by the client or the file watcher results in the file being re-processed.
  */
-class Project {
+export class Project {
     static RootSuffix = '/pack.mcmeta';
     /** Prevent circular binding. */
     #bindingInProgressUris = new Set();
@@ -290,7 +290,7 @@ class Project {
         const listDependencyFiles = async () => {
             const dependencies = await getDependencies();
             const fileUriSupporter = await FileUriSupporter.create(dependencies, this.externals, this.logger);
-            const archiveUriSupporter = await ArchiveUriSupporter.create(dependencies, this.externals, this.logger, this.cacheService.checksums.roots);
+            const archiveUriSupporter = await ArchiveUriSupporter.create(dependencies, this.externals, this.logger);
             this.fs.register('file:', fileUriSupporter, true);
             this.fs.register(ArchiveUriSupporter.Protocol, archiveUriSupporter, true);
         };
@@ -721,5 +721,4 @@ __decorate([
 __decorate([
     SingletonPromise()
 ], Project.prototype, "ensureClientManagedChecked", null);
-export { Project };
 //# sourceMappingURL=Project.js.map

package/lib/service/fileUtil.d.ts

@@ -57,6 +57,7 @@ export declare namespace fileUtil {
     function chmod(externals: Externals, path: FsLocation, mode: number): Promise<void>;
     function ensureWritable(externals: Externals, path: FsLocation): Promise<void>;
     function markReadOnly(externals: Externals, path: FsLocation): Promise<void>;
+    function unlink(externals: Externals, path: FsLocation): Promise<void>;
     function readFile(externals: Externals, path: FsLocation): Promise<Uint8Array>;
     /**
      * @throws

package/lib/service/fileUtil.js

@@ -123,6 +123,10 @@ export var fileUtil;
         return chmod(externals, path, 0o444);
     }
     fileUtil.markReadOnly = markReadOnly;
+    async function unlink(externals, path) {
+        return externals.fs.unlink(path);
+    }
+    fileUtil.unlink = unlink;
     async function readFile(externals, path) {
         return externals.fs.readFile(path);
     }

package/lib/source/IndexMap.js

@@ -1,11 +1,11 @@
 import { Range } from './Range.js';
 export var IndexMap;
 (function (IndexMap) {
-    function convertOffset(map, offset, from, to, isEndOffset) {
+    function convertOffset(map, offset, from, to) {
         let ans = offset;
         for (const pair of map) {
-            if (Range.contains(pair[from], offset, isEndOffset)) {
-                return isEndOffset ? pair[to].end : pair[to].start;
+            if (Range.contains(pair[from], offset)) {
+                return pair[to].start;
             }
             else if (Range.endsBefore(pair[from], offset)) {
                 ans = offset - pair[from].end + pair[to].end;
@@ -17,19 +17,19 @@ export var IndexMap;
         return ans;
     }
     function toInnerOffset(map, offset) {
-        return convertOffset(map, offset, 'outer', 'inner', false);
+        return convertOffset(map, offset, 'outer', 'inner');
     }
     IndexMap.toInnerOffset = toInnerOffset;
     function toInnerRange(map, outer) {
-        return Range.create(toInnerOffset(map, outer.start), convertOffset(map, outer.end, 'outer', 'inner', true));
+        return Range.create(toInnerOffset(map, outer.start), toInnerOffset(map, outer.end));
     }
     IndexMap.toInnerRange = toInnerRange;
     function toOuterOffset(map, offset) {
-        return convertOffset(map, offset, 'inner', 'outer', false);
+        return convertOffset(map, offset, 'inner', 'outer');
     }
     IndexMap.toOuterOffset = toOuterOffset;
     function toOuterRange(map, inner) {
-        return Range.create(toOuterOffset(map, inner.start), convertOffset(map, inner.end, 'inner', 'outer', true));
+        return Range.create(toOuterOffset(map, inner.start), toOuterOffset(map, inner.end));
     }
     IndexMap.toOuterRange = toOuterRange;
     function merge(outerMap, innerMap) {

package/lib/source/LanguageError.d.ts

@@ -16,13 +16,13 @@ export interface LanguageError extends LanguageErrorData {
 export interface PosRangeLanguageError extends LanguageErrorData {
     posRange: PositionRange;
 }
-export declare const LanguageError: Readonly<{
-    create(message: string, range: Range, severity?: ErrorSeverity, info?: LanguageErrorInfo): LanguageError;
+export declare namespace LanguageError {
+    function create(message: string, range: Range, severity?: ErrorSeverity, info?: LanguageErrorInfo): LanguageError;
     /**
      * @returns A {@link PosRangeLanguageError}.
      */
-    withPosRange(error: LanguageError, doc: TextDocument): PosRangeLanguageError;
-}>;
+    function withPosRange(error: LanguageError, doc: TextDocument): PosRangeLanguageError;
+}
 export declare const enum ErrorSeverity {
     Hint = 0,
     Information = 1,

package/lib/source/LanguageError.js

@@ -1,22 +1,25 @@
 import { PositionRange } from './PositionRange.js';
-export const LanguageError = Object.freeze({
-    create(message, range, severity = 3 /* ErrorSeverity.Error */, info) {
+export var LanguageError;
+(function (LanguageError) {
+    function create(message, range, severity = 3 /* ErrorSeverity.Error */, info) {
         const ans = { range, message, severity };
         if (info) {
             ans.info = info;
         }
         return ans;
-    },
+    }
+    LanguageError.create = create;
     /**
      * @returns A {@link PosRangeLanguageError}.
      */
-    withPosRange(error, doc) {
+    function withPosRange(error, doc) {
         return {
             posRange: PositionRange.from(error.range, doc),
             message: error.message,
             severity: error.severity,
             ...(error.info && { info: error.info }),
         };
-    },
-});
+    }
+    LanguageError.withPosRange = withPosRange;
+})(LanguageError || (LanguageError = {}));
 //# sourceMappingURL=LanguageError.js.map

package/lib/source/Source.d.ts

@@ -62,7 +62,7 @@ export declare class Source extends ReadonlySource {
     read(): string;
     /**
      * Skips the current character.
-     * @param step The step to skip. @default 1
+     * @param step The step to skip. Defaults to 1
      */
     skip(step?: number): this;
     /**
@@ -110,11 +110,13 @@ export declare class Source extends ReadonlySource {
     skipUntilLineEnd(): this;
     readRemaining(): string;
     skipRemaining(): this;
-    static isDigit(c: string): c is Digit;
-    static isBrigadierQuote(c: string): c is '"' | "'";
-    static isNewline(c: string): c is Newline;
-    static isSpace(c: string): c is Space;
-    static isWhitespace(c: string): c is Whitespace;
+}
+export declare namespace Source {
+    function isDigit(c: string): c is Digit;
+    function isBrigadierQuote(c: string): c is '"' | "'";
+    function isNewline(c: string): c is Newline;
+    function isSpace(c: string): c is Space;
+    function isWhitespace(c: string): c is Whitespace;
 }
 export {};
 //# sourceMappingURL=Source.d.ts.map

package/lib/source/Source.js

@@ -79,10 +79,10 @@ export class ReadonlySource {
     hasNonSpaceAheadInLine() {
         for (let cursor = this.innerCursor; cursor < this.string.length; cursor++) {
             const c = this.string.charAt(cursor);
-            if (c === CR || c === LF) {
+            if (Source.isNewline(c)) {
                 break;
             }
-            if (!(c === ' ' || c === '\t')) {
+            if (!Source.isSpace(c)) {
                 return true;
             }
         }
@@ -134,7 +134,7 @@ export class Source extends ReadonlySource {
     }
     /**
      * Skips the current character.
-     * @param step The step to skip. @default 1
+     * @param step The step to skip. Defaults to 1
      */
     skip(step = 1) {
         this.innerCursor += step;
@@ -266,20 +266,27 @@ export class Source extends ReadonlySource {
         this.readRemaining();
         return this;
     }
-    static isDigit(c) {
+}
+(function (Source) {
+    function isDigit(c) {
         return c >= '0' && c <= '9';
     }
-    static isBrigadierQuote(c) {
+    Source.isDigit = isDigit;
+    function isBrigadierQuote(c) {
         return c === '"' || c === "'";
     }
-    static isNewline(c) {
+    Source.isBrigadierQuote = isBrigadierQuote;
+    function isNewline(c) {
         return c === '\r\n' || c === '\r' || c === '\n';
     }
-    static isSpace(c) {
+    Source.isNewline = isNewline;
+    function isSpace(c) {
         return c === ' ' || c === '\t';
     }
-    static isWhitespace(c) {
+    Source.isSpace = isSpace;
+    function isWhitespace(c) {
         return Source.isSpace(c) || Source.isNewline(c);
     }
-}
+    Source.isWhitespace = isWhitespace;
+})(Source || (Source = {}));
 //# sourceMappingURL=Source.js.map