@spyglassmc/core 0.1.0

package/lib/processor/formatter/builtin.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFormatters = exports.string = exports.resourceLocation = exports.long = exports.literal = exports.integer = exports.float = exports.comment = exports.boolean = exports.file = exports.fallback = void 0;
+const node_1 = require("../../node");
+const fallback = node => {
+    throw new Error(`No formatter registered for type ${node.type}`);
+};
+exports.fallback = fallback;
+const file = (node, ctx) => {
+    return node.children.map(child => {
+        return ctx.meta.getFormatter(child.type)(child, ctx);
+    }).join('');
+};
+exports.file = file;
+const boolean = node => {
+    return node.value ? 'true' : 'false';
+};
+exports.boolean = boolean;
+const comment = node => {
+    return '#' + node.comment;
+};
+exports.comment = comment;
+const float = node => {
+    return node.value.toString();
+};
+exports.float = float;
+const integer = node => {
+    return node.value.toFixed();
+};
+exports.integer = integer;
+const literal = node => {
+    return node.value;
+};
+exports.literal = literal;
+const long = node => {
+    return node.value.toString();
+};
+exports.long = long;
+const resourceLocation = node => {
+    return node_1.ResourceLocationNode.toString(node, 'origin');
+};
+exports.resourceLocation = resourceLocation;
+const string = node => {
+    // FIXME: escape this value according to the node's IndexMap and context
+    return `"${node.value}"`;
+};
+exports.string = string;
+function registerFormatters(meta) {
+    meta.registerFormatter('file', exports.file);
+    meta.registerFormatter('boolean', exports.boolean);
+    meta.registerFormatter('comment', exports.comment);
+    meta.registerFormatter('float', exports.float);
+    meta.registerFormatter('integer', exports.integer);
+    meta.registerFormatter('long', exports.long);
+    meta.registerFormatter('literal', exports.literal);
+    meta.registerFormatter('resource_location', exports.resourceLocation);
+    meta.registerFormatter('string', exports.string);
+}
+exports.registerFormatters = registerFormatters;
+//# sourceMappingURL=builtin.js.map

package/lib/processor/formatter/index.d.ts

@@ -0,0 +1,3 @@
+export * as formatter from './builtin';
+export * from './Formatter';
+//# sourceMappingURL=index.d.ts.map

package/lib/processor/formatter/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatter = void 0;
+exports.formatter = __importStar(require("./builtin"));
+__exportStar(require("./Formatter"), exports);
+//# sourceMappingURL=index.js.map

package/lib/processor/index.d.ts

@@ -0,0 +1,10 @@
+export * from './checker';
+export * from './ColorInfoProvider';
+export * from './colorizer';
+export * from './completer';
+export * from './formatter';
+export * from './InlayHintProvider';
+export * from './linter';
+export * from './SignatureHelpProvider';
+export * from './util';
+//# sourceMappingURL=index.d.ts.map

package/lib/processor/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./checker"), exports);
+__exportStar(require("./ColorInfoProvider"), exports);
+__exportStar(require("./colorizer"), exports);
+__exportStar(require("./completer"), exports);
+__exportStar(require("./formatter"), exports);
+__exportStar(require("./InlayHintProvider"), exports);
+__exportStar(require("./linter"), exports);
+__exportStar(require("./SignatureHelpProvider"), exports);
+__exportStar(require("./util"), exports);
+//# sourceMappingURL=index.js.map

package/lib/processor/linter/Linter.d.ts

@@ -0,0 +1,4 @@
+import type { AstNode } from '../../node';
+import type { LinterContext } from '../../service';
+export declare type Linter<N extends AstNode> = (node: N, ctx: LinterContext) => void;
+//# sourceMappingURL=Linter.d.ts.map

package/lib/processor/linter/Linter.js

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

package/lib/processor/linter/builtin/undeclaredSymbol.d.ts

@@ -0,0 +1,4 @@
+import type { AstNode } from '../../../node';
+import type { Linter } from '../Linter';
+export declare const undeclaredSymbol: Linter<AstNode>;
+//# sourceMappingURL=undeclaredSymbol.d.ts.map

package/lib/processor/linter/builtin/undeclaredSymbol.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undeclaredSymbol = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const common_1 = require("../../../common");
+const service_1 = require("../../../service");
+const symbol_1 = require("../../../symbol");
+const undeclaredSymbol = (node, ctx) => {
+    if (!node.symbol || symbol_1.SymbolUtil.isDeclared(node.symbol)) {
+        return;
+    }
+    const action = getAction(ctx.ruleValue, node.symbol, ctx);
+    if (service_1.SymbolLinterConfig.Action.isDeclare(action)) {
+        ctx.symbols
+            .query({ doc: ctx.doc, node }, node.symbol.category, ...node.symbol.path)
+            .amend({
+            data: { visibility: getVisibility(action.declare) },
+            usage: { type: 'declaration', node },
+        });
+    }
+    if (service_1.SymbolLinterConfig.Action.isReport(action)) {
+        const severityOverride = action.report === 'inherit' ? undefined : service_1.LinterSeverity.toErrorSeverity(action.report);
+        ctx.err.lint((0, locales_1.localize)('linter.undeclared-symbol.message', node.symbol.category, (0, locales_1.localeQuote)(node.symbol.identifier)), node, undefined, severityOverride);
+    }
+};
+exports.undeclaredSymbol = undeclaredSymbol;
+function getAction(config, symbol, ctx) {
+    if (service_1.SymbolLinterConfig.Action.is(config)) {
+        return config;
+    }
+    function test(conditions) {
+        function testSingleCondition(condition) {
+            const resourceLocation = common_1.ResourceLocation.lengthen(symbol.identifier);
+            const namespace = resourceLocation.slice(0, resourceLocation.indexOf(common_1.ResourceLocation.NamespacePathSep));
+            return ((condition.category ? common_1.Arrayable.toArray(condition.category).includes(symbol.category) : true) &&
+                (condition.namespace ? common_1.Arrayable.toArray(condition.namespace).includes(namespace) : true) &&
+                (condition.excludeNamespace ? !common_1.Arrayable.toArray(condition.excludeNamespace).includes(namespace) : true) &&
+                (condition.pattern ? common_1.Arrayable.toArray(condition.pattern).some(p => new RegExp(p).test(symbol.identifier)) : true) &&
+                (condition.excludePattern ? !common_1.Arrayable.toArray(condition.excludePattern).some(p => new RegExp(p).test(symbol.identifier)) : true));
+        }
+        try {
+            return common_1.Arrayable.toArray(conditions).some(testSingleCondition);
+        }
+        catch (e) {
+            // Illegal RegExp.
+            ctx.logger.error('[undeclaredSymbol#getAction] Likely encountered an illegal regular expression in the config', e);
+            return false;
+        }
+    }
+    function evaluateComplexes(complexes) {
+        for (const complex of common_1.Arrayable.toArray(complexes)) {
+            if (complex.if && !test(complex.if)) {
+                continue;
+            }
+            return complex.override
+                ? evaluateComplexes(complex.override) ?? complex.then
+                : complex.then;
+        }
+        return undefined;
+    }
+    return evaluateComplexes(config);
+}
+function getVisibility(input) {
+    switch (input) {
+        case 'block':
+            return 0 /* Block */;
+        case 'file':
+            return 1 /* File */;
+        case 'public':
+            return 2 /* Public */;
+    }
+}
+//# sourceMappingURL=undeclaredSymbol.js.map

package/lib/processor/linter/builtin.d.ts

@@ -0,0 +1,15 @@
+import type { AstNode, StringBaseNode } from '../../node';
+import type { Logger, MetaRegistry } from '../../service';
+import type { Linter } from './Linter';
+export declare const noop: Linter<AstNode>;
+/**
+ * @param key The name of the key on the {@link AstNode} that contains the value to be validated.
+ */
+export declare function nameConvention(key: string): Linter<AstNode>;
+export declare const quote: Linter<StringBaseNode>;
+export declare namespace configValidator {
+    function nameConvention(name: string, val: unknown, logger: Logger): boolean;
+    function symbolLinterConfig(_name: string, value: unknown, _logger: Logger): boolean;
+}
+export declare function registerLinters(meta: MetaRegistry): void;
+//# sourceMappingURL=builtin.d.ts.map

package/lib/processor/linter/builtin.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLinters = exports.configValidator = exports.quote = exports.nameConvention = exports.noop = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const parser_1 = require("../../parser");
+const service_1 = require("../../service");
+const symbol_1 = require("../../symbol");
+const undeclaredSymbol_1 = require("./builtin/undeclaredSymbol");
+const noop = () => { };
+exports.noop = noop;
+/**
+ * @param key The name of the key on the {@link AstNode} that contains the value to be validated.
+ */
+function nameConvention(key) {
+    return (node, ctx) => {
+        if (typeof node[key] !== 'string') {
+            throw new Error(`Trying to access property "${key}" of node type "${node.type}"`);
+        }
+        const name = node[key];
+        try {
+            // SECURITY: ReDoS attack. The risk is acceptable at the moment.
+            const regex = new RegExp(ctx.ruleValue);
+            if (!name.match(regex)) {
+                ctx.err.lint((0, locales_1.localize)('linter.name-convention.illegal', (0, locales_1.localeQuote)(name), (0, locales_1.localeQuote)(ctx.ruleValue)), node);
+            }
+        }
+        catch (e) {
+            ctx.logger.error(`[nameConvention linter] The value “${ctx.ruleValue}” set for rule “${ctx.ruleName}” is not a valid regular expression.`, e);
+        }
+    };
+}
+exports.nameConvention = nameConvention;
+const quote = (node, ctx) => {
+    const config = ctx.ruleValue;
+    const mustValueBeQuoted = node.options.unquotable
+        ? [...node.value].some(c => !(0, parser_1.isAllowedCharacter)(c, node.options.unquotable))
+        : true;
+    const isQuoteRequired = config.always || mustValueBeQuoted;
+    const isQuoteProhibited = config.always === false && !mustValueBeQuoted;
+    const firstChar = ctx.src.slice(node.range.start, node.range.start + 1);
+    const isFirstCharQuote = !!node.options.quotes?.includes(firstChar);
+    if (isQuoteRequired) {
+        if (isFirstCharQuote) {
+            // TODO: Check type
+            config.avoidEscape;
+            config.type;
+        }
+        else {
+            // TODO: Error quote expected
+        }
+    }
+    else if (isQuoteProhibited && isFirstCharQuote) {
+        // TODO: Error no quote expected
+    }
+};
+exports.quote = quote;
+var configValidator;
+(function (configValidator) {
+    function getDocLink(name) {
+        return `https://spyglassmc.com/user/lint/${name}`;
+    }
+    function wrapError(name, msg) {
+        return `[Invalid Linter Config] [${name}] ${(0, locales_1.localize)('linter-config-validator.wrapper', msg, getDocLink(name))}`;
+    }
+    function nameConvention(name, val, logger) {
+        if (typeof val !== 'string') {
+            logger.error(wrapError(name, (0, locales_1.localize)('linter-config-validator.name-convention.type')));
+            return false;
+        }
+        try {
+            // SECURITY: ReDoS attack. The risk is acceptable at the moment.
+            new RegExp(val);
+        }
+        catch (e) {
+            logger.error(wrapError(name, (0, locales_1.localize)('') // FIXME
+            ), e);
+            return false;
+        }
+        return true;
+    }
+    configValidator.nameConvention = nameConvention;
+    function symbolLinterConfig(_name, value, _logger) {
+        return service_1.SymbolLinterConfig.is(value);
+    }
+    configValidator.symbolLinterConfig = symbolLinterConfig;
+})(configValidator = exports.configValidator || (exports.configValidator = {}));
+function registerLinters(meta) {
+    meta.registerLinter('nameOfNbtKey', {
+        configValidator: configValidator.nameConvention,
+        linter: nameConvention('value'),
+        nodePredicate: n => n.parent?.parent?.type === 'nbt:compound' && n.parent.type === 'pair' && n.type === 'string',
+    });
+    meta.registerLinter('nameOfObjective', {
+        configValidator: configValidator.nameConvention,
+        linter: nameConvention('value'),
+        nodePredicate: n => n.symbol && n.symbol.category === 'objective',
+    });
+    meta.registerLinter('nameOfScoreHolder', {
+        configValidator: configValidator.nameConvention,
+        linter: nameConvention('value'),
+        nodePredicate: n => n.symbol && n.symbol.category === 'score_holder',
+    });
+    meta.registerLinter('nameOfTag', {
+        configValidator: configValidator.nameConvention,
+        linter: nameConvention('value'),
+        nodePredicate: n => n.symbol && n.symbol.category === 'tag',
+    });
+    meta.registerLinter('nameOfTeam', {
+        configValidator: configValidator.nameConvention,
+        linter: nameConvention('value'),
+        nodePredicate: n => n.symbol && n.symbol.category === 'team',
+    });
+    meta.registerLinter('undeclaredSymbol', {
+        configValidator: configValidator.symbolLinterConfig,
+        linter: undeclaredSymbol_1.undeclaredSymbol,
+        nodePredicate: n => n.symbol && !symbol_1.NbtdocCategories.includes(n.symbol.category),
+    });
+}
+exports.registerLinters = registerLinters;
+//# sourceMappingURL=builtin.js.map

package/lib/processor/linter/index.d.ts

@@ -0,0 +1,3 @@
+export * as linter from './builtin';
+export * from './Linter';
+//# sourceMappingURL=index.d.ts.map

package/lib/processor/linter/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linter = void 0;
+exports.linter = __importStar(require("./builtin"));
+__exportStar(require("./Linter"), exports);
+//# sourceMappingURL=index.js.map

package/lib/processor/util.d.ts

@@ -0,0 +1,17 @@
+import type { AstNode } from '../node';
+import { Range } from '../source';
+declare type Callback<R> = (this: void, node: AstNode, parents: AstNode[]) => R;
+export declare function traversePreOrder(node: AstNode, shouldContinue: Callback<unknown>, shouldCallFn: Callback<unknown>, fn: Callback<unknown>): void;
+interface NodeResult {
+    node: AstNode | undefined;
+    /**
+     * Ordered from the closest parent to the root node.
+     */
+    parents: AstNode[];
+}
+/**
+ * @returns The shallowest node that is fully contained within `range`.
+ */
+export declare function findNode(node: AstNode, range: Range): NodeResult;
+export {};
+//# sourceMappingURL=util.d.ts.map

package/lib/processor/util.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNode = exports.traversePreOrder = void 0;
+const source_1 = require("../source");
+function traversePreOrder(node, shouldContinue, shouldCallFn, fn) {
+    traversePreOrderImpl(node, shouldContinue, shouldCallFn, fn, []);
+}
+exports.traversePreOrder = traversePreOrder;
+function traversePreOrderImpl(node, shouldContinue, shouldCallFn, fn, parents) {
+    if (shouldCallFn(node, parents)) {
+        fn(node, parents);
+    }
+    if (!node.children || !shouldContinue(node, parents)) {
+        return;
+    }
+    for (const child of node.children ?? []) {
+        parents.unshift(node);
+        traversePreOrderImpl(child, shouldContinue, shouldCallFn, fn, parents);
+        parents.shift();
+    }
+}
+/**
+ * @returns The shallowest node that is fully contained within `range`.
+ */
+function findNode(node, range) {
+    let ans = { node: undefined, parents: [] };
+    // TODO: Binary search here.
+    traversePreOrder(node, (node) => ans.node === undefined && source_1.Range.intersects(node.range, range), (node) => source_1.Range.containsRange(range, node.range), (node, parents) => ans = { node, parents: [...parents] });
+    return ans;
+}
+exports.findNode = findNode;
+//# sourceMappingURL=util.js.map

package/lib/service/CacheService.d.ts

@@ -0,0 +1,54 @@
+import { SymbolTable } from '../symbol';
+import type { RootUriString } from './fileUtil';
+import type { Project } from './Project';
+/**
+ * The format version of the cache. Should be increased when any changes that
+ * could invalidate the cache are introduced to the Spyglass codebase.
+ */
+export declare const LatestCacheVersion = 1;
+/**
+ * Checksums of cached files or roots.
+ */
+interface Checksums {
+    files: Record<string, string>;
+    roots: Record<RootUriString, string>;
+    symbolRegistrars: Record<string, string>;
+}
+declare namespace Checksums {
+    function create(): Checksums;
+}
+interface LoadResult {
+    symbols: SymbolTable;
+}
+interface ValidateResult {
+    addedFiles: string[];
+    changedFiles: string[];
+    removedFiles: string[];
+    unchangedFiles: string[];
+}
+export declare class CacheService {
+    #private;
+    private readonly cacheRoot;
+    private readonly project;
+    checksums: Checksums;
+    /**
+     * @param cacheRoot File path to the directory where cache files by Spyglass should be stored.
+     * @param project
+     */
+    constructor(cacheRoot: string, project: Project);
+    /**
+     * @throws
+     *
+     * @returns `${cacheRoot}/symbols/${sha1(projectRoot)}.json`
+     */
+    private getCacheFilePath;
+    load(): Promise<LoadResult>;
+    validate(): Promise<ValidateResult>;
+    /**
+     * @returns If the cache file was saved successfully.
+     */
+    save(): Promise<boolean>;
+    reset(): void;
+}
+export {};
+//# sourceMappingURL=CacheService.d.ts.map