@spyglassmc/core 0.1.1 → 0.3.0

package/lib/parser/util.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.acceptOnly = exports.stopBefore = exports.validate = exports.setType = exports.map = exports.select = exports.recover = exports.optional = exports.failOnEmpty = exports.any = exports.repeat = exports.sequence = exports.attempt = void 0;
-const node_1 = require("../node");
-const service_1 = require("../service");
-const source_1 = require("../source");
-const Parser_1 = require("./Parser");
-function attempt(parser, src, ctx) {
+import { SequenceUtil, SequenceUtilDiscriminator } from '../node/index.js';
+import { ErrorReporter } from '../service/index.js';
+import { Range } from '../source/index.js';
+import { Failure } from './Parser.js';
+export function attempt(parser, src, ctx) {
     const tmpSrc = src.clone();
     const tmpCtx = {
         ...ctx,
-        err: new service_1.ErrorReporter(),
-        symbols: ctx.symbols.clone(),
+        err: new ErrorReporter(),
     };
     const result = parser(tmpSrc, tmpCtx);
     return {
@@ -20,17 +16,15 @@ function attempt(parser, src, ctx) {
         updateSrcAndCtx: () => {
             src.innerCursor = tmpSrc.innerCursor;
             ctx.err.absorb(tmpCtx.err);
-            tmpCtx.symbols.applyDelayedEdits();
         },
     };
 }
-exports.attempt = attempt;
-function sequence(parsers, parseGap) {
+export function sequence(parsers, parseGap) {
     return (src, ctx) => {
         const ans = {
-            isSequenceUtil: true,
+            [SequenceUtilDiscriminator]: true,
             children: [],
-            range: source_1.Range.create(src),
+            range: Range.create(src),
         };
         for (const [i, p] of parsers.entries()) {
             const parser = typeof p === 'function' ? p : p.get(ans);
@@ -41,13 +35,13 @@ function sequence(parsers, parseGap) {
                 ans.children.push(...parseGap(src, ctx));
             }
             const result = parser(src, ctx);
-            if (result === Parser_1.Failure) {
-                return Parser_1.Failure;
+            if (result === Failure) {
+                return Failure;
             }
             else if (result === undefined) {
                 continue;
             }
-            else if (node_1.SequenceUtil.is(result)) {
+            else if (SequenceUtil.is(result)) {
                 ans.children.push(...result.children);
             }
             else {
@@ -58,24 +52,23 @@ function sequence(parsers, parseGap) {
         return ans;
     };
 }
-exports.sequence = sequence;
-function repeat(parser, parseGap) {
+export function repeat(parser, parseGap) {
     return (src, ctx) => {
         const ans = {
-            isSequenceUtil: true,
+            [SequenceUtilDiscriminator]: true,
             children: [],
-            range: source_1.Range.create(src),
+            range: Range.create(src),
         };
         while (src.canRead()) {
             if (parseGap) {
                 ans.children.push(...parseGap(src, ctx));
             }
             const { result, updateSrcAndCtx } = attempt(parser, src, ctx);
-            if (result === Parser_1.Failure) {
+            if (result === Failure) {
                 break;
             }
             updateSrcAndCtx();
-            if (node_1.SequenceUtil.is(result)) {
+            if (SequenceUtil.is(result)) {
                 ans.children.push(...result.children);
             }
             else {
@@ -86,18 +79,17 @@ function repeat(parser, parseGap) {
         return ans;
     };
 }
-exports.repeat = repeat;
-function any(parsers, out) {
+export function any(parsers, out) {
     return (src, ctx) => {
         const results = parsers
             .map((parser, i) => ({ attempt: attempt(parser, src, ctx), index: i }))
-            .filter(({ attempt }) => attempt.result !== Parser_1.Failure)
+            .filter(({ attempt }) => attempt.result !== Failure)
             .sort((a, b) => (b.attempt.endCursor - a.attempt.endCursor) || (a.attempt.errorAmount - b.attempt.errorAmount));
         if (results.length === 0) {
             if (out) {
                 out.index = -1;
             }
-            return Parser_1.Failure;
+            return Failure;
         }
         results[0].attempt.updateSrcAndCtx();
         if (out) {
@@ -106,11 +98,10 @@ function any(parsers, out) {
         return results[0].attempt.result;
     };
 }
-exports.any = any;
 /**
  * @returns A parser that fails when the passed-in parser didn't move the cursor at all.
  */
-function failOnEmpty(parser) {
+export function failOnEmpty(parser) {
     return (src, ctx) => {
         const start = src.cursor;
         const { endCursor, updateSrcAndCtx, result } = attempt(parser, src, ctx);
@@ -118,68 +109,78 @@ function failOnEmpty(parser) {
             updateSrcAndCtx();
             return result;
         }
-        return Parser_1.Failure;
+        return Failure;
     };
 }
-exports.failOnEmpty = failOnEmpty;
-function optional(parser) {
-    // return any<N | undefined>([
-    // 	parser,
-    // 	empty,
-    // ])
+/**
+ * @returns A parser that fails when the passed-in parser produced any errors.
+ */
+export function failOnError(parser) {
     return (src, ctx) => {
+        const start = src.cursor;
+        const { errorAmount, updateSrcAndCtx, result } = attempt(parser, src, ctx);
+        if (!errorAmount) {
+            updateSrcAndCtx();
+            return result;
+        }
+        return Failure;
+    };
+}
+export function optional(parser) {
+    return ((src, ctx) => {
         const { result, updateSrcAndCtx } = attempt(parser, src, ctx);
-        if (result === Parser_1.Failure) {
+        if (result === Failure) {
             return undefined;
         }
         else {
             updateSrcAndCtx();
             return result;
         }
-    };
+    });
 }
-exports.optional = optional;
-function recover(parser, defaultValue) {
+export function recover(parser, defaultValue) {
     return (src, ctx) => {
         const result = parser(src, ctx);
-        if (result === Parser_1.Failure) {
+        if (result === Failure) {
             const ans = defaultValue(src, ctx);
             return ans;
         }
         return result;
     };
 }
-exports.recover = recover;
-function select(cases) {
+export function select(cases) {
     return (src, ctx) => {
-        for (const { predicate, parser } of cases) {
-            if (predicate?.(src) ?? true) {
-                return parser(src, ctx);
+        for (const { predicate, prefix, parser } of cases) {
+            if (predicate?.(src) ?? (prefix !== undefined ? src.tryPeek(prefix) : undefined) ?? true) {
+                const callableParser = typeof parser === 'object' ? parser.get() : parser;
+                return callableParser(src, ctx);
             }
         }
-        return Parser_1.Failure;
+        throw new Error('The select parser util was called with non-exhaustive cases');
     };
 }
-exports.select = select;
-function map(parser, fn) {
+export function map(parser, fn) {
     return (src, ctx) => {
         const result = parser(src, ctx);
-        if (result === Parser_1.Failure) {
-            return Parser_1.Failure;
+        if (result === Failure) {
+            return Failure;
         }
         const ans = fn(result, src, ctx);
         return ans;
     };
 }
-exports.map = map;
-function setType(type, parser) {
-    return map(parser, res => ({
-        ...res,
-        type,
-    }));
+export function setType(type, parser) {
+    return map(parser, res => {
+        const { type: _type, ...restResult } = res;
+        const ans = {
+            type,
+            ...restResult,
+        };
+        delete ans[SequenceUtilDiscriminator];
+        return ans;
+    });
 }
-exports.setType = setType;
-function validate(parser, validator, message, severity) {
+export function validate(parser, validator, message, severity) {
     return map(parser, (res, src, ctx) => {
         const isLegal = validator(res, src, ctx);
         if (!isLegal) {
@@ -188,8 +189,7 @@ function validate(parser, validator, message, severity) {
         return res;
     });
 }
-exports.validate = validate;
-function stopBefore(parser, ...teminators) {
+export function stopBefore(parser, ...teminators) {
     const flatTerminators = teminators.flat();
     return (src, ctx) => {
         const tmpSrc = src.clone();
@@ -203,8 +203,7 @@ function stopBefore(parser, ...teminators) {
         return ans;
     };
 }
-exports.stopBefore = stopBefore;
-function acceptOnly(parser, ...characters) {
+export function acceptOnly(parser, ...characters) {
     const set = new Set(characters.flat());
     return (src, ctx) => {
         const tmpSrc = src.clone();
@@ -220,5 +219,19 @@ function acceptOnly(parser, ...characters) {
         return ans;
     };
 }
-exports.acceptOnly = acceptOnly;
+export function acceptIf(parser, predicate) {
+    return ((src, ctx) => {
+        const tmpSrc = src.clone();
+        // Cut tmpSrc.string before the nearest unacceptable character.
+        for (let i = tmpSrc.innerCursor; i < tmpSrc.string.length; i++) {
+            if (!predicate(tmpSrc.string.charAt(i))) {
+                tmpSrc.string = tmpSrc.string.slice(0, i);
+                break;
+            }
+        }
+        const ans = parser(tmpSrc, ctx);
+        src.innerCursor = tmpSrc.innerCursor;
+        return ans;
+    });
+}
 //# sourceMappingURL=util.js.map

package/lib/processor/ColorInfoProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Range } from '../source';
+import type { Range } from '../source/index.js';
 export interface ColorInfo {
     range: Range;
     color: Color;

package/lib/processor/ColorInfoProvider.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColorPresentation = exports.ColorFormat = exports.Color = void 0;
-var Color;
+export var Color;
 (function (Color) {
     Color.NamedColors = new Map([
         ['aqua', 0x55ffff],
@@ -75,8 +72,8 @@ var Color;
         return fromIntRGB(r, g, b);
     }
     Color.fromCompositeInt = fromCompositeInt;
-})(Color = exports.Color || (exports.Color = {}));
-var ColorFormat;
+})(Color || (Color = {}));
+export var ColorFormat;
 (function (ColorFormat) {
     /**
      * `1 0.6 0.2 1.0`
@@ -106,8 +103,8 @@ var ColorFormat;
      * `16620441`
      */
     ColorFormat[ColorFormat["CompositeInt"] = 6] = "CompositeInt";
-})(ColorFormat = exports.ColorFormat || (exports.ColorFormat = {}));
-var ColorPresentation;
+})(ColorFormat || (ColorFormat = {}));
+export var ColorPresentation;
 (function (ColorPresentation) {
     function fromColorFormat(format, color, range) {
         const presentation = colorPresentation(format, color);
@@ -137,5 +134,5 @@ var ColorPresentation;
                 return `${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255)}`;
         }
     }
-})(ColorPresentation = exports.ColorPresentation || (exports.ColorPresentation = {}));
+})(ColorPresentation || (ColorPresentation = {}));
 //# sourceMappingURL=ColorInfoProvider.js.map

package/lib/processor/InlayHintProvider.d.ts

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

package/lib/processor/InlayHintProvider.js

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

package/lib/processor/SignatureHelpProvider.d.ts

@@ -1,5 +1,6 @@
-import type { AstNode } from '../node';
-import type { SignatureHelpProviderContext } from '../service';
+import type { DeepReadonly } from '../common/index.js';
+import type { AstNode } from '../node/index.js';
+import type { SignatureHelpProviderContext } from '../service/index.js';
 export interface SignatureHelp {
     signatures: SignatureInfo[];
     activeSignature: number;
@@ -14,5 +15,5 @@ export interface ParameterInfo {
     label: [number, number];
     documentation?: string;
 }
-export declare type SignatureHelpProvider<N = AstNode> = (node: N, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
+export declare type SignatureHelpProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
 //# sourceMappingURL=SignatureHelpProvider.d.ts.map

package/lib/processor/SignatureHelpProvider.js

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

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

@@ -0,0 +1,26 @@
+import type { AstNode } from '../../node/index.js';
+import type { BinderContext } from '../../service/index.js';
+declare const IsAsync: unique symbol;
+export declare type Binder<N extends AstNode> = SyncBinder<N> | AsyncBinder<N>;
+export interface SyncBinderInitializer<N extends AstNode> {
+    (node: N, ctx: BinderContext): void;
+}
+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>;
+}>;
+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 {};
+//# sourceMappingURL=Binder.d.ts.map

package/lib/processor/binder/Binder.js

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

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

@@ -0,0 +1,27 @@
+import type { AstNode, SymbolBaseNode } from '../../node/index.js';
+import { ResourceLocationNode } from '../../node/index.js';
+import type { BinderContext, MetaRegistry } from '../../service/index.js';
+import type { Binder } from './Binder.js';
+import { AsyncBinder, SyncBinder } from './Binder.js';
+export declare type AttemptResult = {
+    errorAmount: number;
+    totalErrorSpan: number;
+    updateNodeAndCtx: () => void;
+};
+export declare function attempt<B extends Binder<never>>(binder: B, node: B extends Binder<infer N extends AstNode> ? N : never, ctx: BinderContext): B extends SyncBinder<any> ? AttemptResult : Promise<AttemptResult>;
+declare type ExtractBinder<B extends Binder<never>> = B extends Binder<infer N extends AstNode> ? N : never;
+export declare function any<Binders extends Binder<never>[]>(binders: Binders): Binders extends SyncBinder<never>[] ? SyncBinder<ExtractBinder<Binders[number]>> : AsyncBinder<ExtractBinder<Binders[number]>>;
+/**
+ * No operation.
+ */
+export declare const noop: SyncBinder<AstNode>;
+/**
+ * Use the shallowest children that have their own binder to validate.
+ */
+export declare const fallback: AsyncBinder<AstNode>;
+export declare const dispatchSync: SyncBinder<AstNode>;
+export declare const resourceLocation: SyncBinder<ResourceLocationNode>;
+export declare const symbol: SyncBinder<SymbolBaseNode>;
+export declare function registerBinders(meta: MetaRegistry): void;
+export {};
+//# sourceMappingURL=builtin.d.ts.map

package/lib/processor/binder/builtin.js

@@ -0,0 +1,116 @@
+import { localize } from '@spyglassmc/locales';
+import { ResourceLocation, StateProxy } from '../../common/index.js';
+import { ResourceLocationNode } from '../../node/index.js';
+import { ErrorReporter } from '../../service/index.js';
+import { traversePreOrder } from '../util.js';
+import { AsyncBinder, SyncBinder } from './Binder.js';
+export function attempt(binder, node, ctx) {
+    const tempCtx = {
+        ...ctx,
+        err: new ErrorReporter(),
+        symbols: ctx.symbols.clone(),
+    };
+    const processAfterBinder = () => {
+        StateProxy.undoChanges(node);
+        const totalErrorSpan = tempCtx.err.errors
+            .map(e => e.range.end - e.range.start)
+            .reduce((a, b) => a + b, 0);
+        return {
+            errorAmount: tempCtx.err.errors.length,
+            totalErrorSpan,
+            updateNodeAndCtx: () => {
+                ctx.err.absorb(tempCtx.err);
+                StateProxy.redoChanges(node);
+                tempCtx.symbols.applyDelayedEdits();
+            },
+        };
+    };
+    if (SyncBinder.is(binder)) {
+        binder(node, tempCtx);
+        return processAfterBinder();
+    }
+    else {
+        return (async () => {
+            await binder(node, tempCtx);
+            return processAfterBinder();
+        })();
+    }
+}
+export function any(binders) {
+    if (binders.length === 0) {
+        throw new Error('Expected at least one binder');
+    }
+    const attemptSorter = (a, b) => a.errorAmount - b.errorAmount || a.totalErrorSpan - b.totalErrorSpan;
+    if (binders.every(SyncBinder.is)) {
+        return SyncBinder.create((node, ctx) => {
+            const attempts = binders
+                .map(binder => attempt(binder, node, ctx))
+                .sort(attemptSorter);
+            attempts[0].updateNodeAndCtx();
+        });
+    }
+    else {
+        return AsyncBinder.create(async (node, ctx) => {
+            const attempts = (await Promise.all(binders.map(binder => attempt(binder, node, ctx))))
+                .sort(attemptSorter);
+            attempts[0].updateNodeAndCtx();
+        });
+    }
+}
+/**
+ * No operation.
+ */
+export const noop = SyncBinder.create(() => { });
+/**
+ * Use the shallowest children that have their own binder to validate.
+ */
+export const fallback = AsyncBinder.create(async (node, ctx) => {
+    const promises = [];
+    traversePreOrder(node, node => !ctx.meta.hasBinder(node.type), node => ctx.meta.hasBinder(node.type), node => {
+        const binder = ctx.meta.getBinder(node.type);
+        const result = binder(node, ctx);
+        if (result instanceof Promise) {
+            promises.push(result);
+        }
+    });
+    await Promise.all(promises);
+});
+export const dispatchSync = SyncBinder.create((node, ctx) => {
+    for (const child of node.children ?? []) {
+        if (ctx.meta.hasBinder(child.type)) {
+            const binder = ctx.meta.getBinder(child.type);
+            binder(child, ctx);
+        }
+    }
+});
+export const resourceLocation = SyncBinder.create((node, ctx) => {
+    if (node.options.category) {
+        const raw = ResourceLocationNode.toString(node, 'full');
+        const sanitizedRaw = ResourceLocation.lengthen(node.options.namespacePathSep === '.'
+            ? raw.replace('.', ResourceLocation.NamespacePathSep)
+            : raw);
+        ctx.symbols
+            .query(ctx.doc, node.isTag ? `tag/${node.options.category}` : node.options.category, sanitizedRaw)
+            .enter({ usage: { type: node.options.usageType, node, accessType: node.options.accessType } });
+    }
+    const full = ResourceLocationNode.toString(node, 'full');
+    if (node.options.pool) {
+        if (!node.options.pool.includes(full)) {
+            ctx.err.report(localize('expected', node.options.pool), node, 3 /* ErrorSeverity.Error */);
+        }
+        return;
+    }
+});
+export const symbol = SyncBinder.create((node, ctx) => {
+    if (node.value) {
+        const path = node.options.parentPath ? [...node.options.parentPath, node.value] : [node.value];
+        ctx.symbols
+            .query(ctx.doc, node.options.category, ...path)
+            .enter({ usage: { type: node.options.usageType, node: node, accessType: node.options.accessType } });
+    }
+});
+export function registerBinders(meta) {
+    meta.registerBinder('resource_location', resourceLocation);
+    meta.registerBinder('symbol', symbol);
+}
+//# sourceMappingURL=builtin.js.map

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

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

package/lib/processor/binder/index.js

@@ -0,0 +1,3 @@
+export * as binder from './builtin.js';
+export * from './Binder.js';
+//# sourceMappingURL=index.js.map

package/lib/processor/checker/Checker.d.ts

@@ -1,5 +1,5 @@
-import type { AstNode } from '../../node';
-import type { CheckerContext } from '../../service';
+import type { AstNode } from '../../node/index.js';
+import type { CheckerContext } from '../../service/index.js';
 export declare type Checker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void> | void;
 export declare type SyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => void;
 export declare type AsyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void>;

package/lib/processor/checker/Checker.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FallbackChecker = void 0;
 /* istanbul ignore next */
-const FallbackChecker = () => Promise.resolve();
-exports.FallbackChecker = FallbackChecker;
+export const FallbackChecker = () => Promise.resolve();
 //# sourceMappingURL=Checker.js.map

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

@@ -1,7 +1,7 @@
-import type { AstNode, SymbolBaseNode } from '../../node';
-import { ResourceLocationNode } from '../../node';
-import type { CheckerContext, MetaRegistry } from '../../service';
-import type { Checker, SyncChecker } from './Checker';
+import type { AstNode, SymbolBaseNode } from '../../node/index.js';
+import { ResourceLocationNode } from '../../node/index.js';
+import type { CheckerContext, MetaRegistry } from '../../service/index.js';
+import type { Checker, SyncChecker } from './Checker.js';
 export declare type AttemptResult = {
     errorAmount: number;
     totalErrorSpan: number;