@spyglassmc/mcdoc 0.3.16 → 0.3.18

package/lib/runtime/attribute/builtin.js

@@ -6,9 +6,11 @@ const idValidator = validator.alternatives(validator.map(validator.string, v =>
     tags: validator.optional(validator.options('allowed', 'implicit', 'required')),
     definition: validator.optional(validator.boolean),
     prefix: validator.optional(validator.options('!')),
+    path: validator.optional(validator.string),
     empty: validator.optional(validator.options('allowed')),
+    exclude: validator.optional(validator.alternatives(validator.map(validator.string, v => [v]), validator.list(validator.string))),
 }), () => ({}));
-function getResourceLocationOptions({ registry, tags, definition }, requireCanonical, ctx, typeDef) {
+function getResourceLocationOptions({ registry, tags, definition, path }, requireCanonical, ctx, typeDef) {
     if (!registry) {
         if (typeDef?.kind === 'enum' && typeDef.enumKind === 'string') {
             return {
@@ -28,24 +30,20 @@ function getResourceLocationOptions({ registry, tags, definition }, requireCanon
         registry = `tag/${registry}`;
     }
     if (tags === 'allowed' || tags === 'required') {
-        if (core.TaggableResourceLocationCategory.is(registry)) {
-            return {
-                category: registry,
-                requireCanonical,
-                allowTag: true,
-                requireTag: tags === 'required',
-            };
-        }
-    }
-    else if (core.ResourceLocationCategory.is(registry)) {
         return {
             category: registry,
             requireCanonical,
-            usageType: definition ? 'definition' : 'reference',
+            allowTag: true,
+            requireTag: tags === 'required',
+            implicitPath: path,
         };
     }
-    ctx.logger.warn(`[mcdoc id] Unhandled registry ${registry}`);
-    return undefined;
+    return {
+        category: registry,
+        requireCanonical,
+        usageType: definition ? 'definition' : 'reference',
+        implicitPath: path,
+    };
 }
 const integerValidator = validator.alternatives(validator.tree({
     min: validator.optional(validator.number),
@@ -122,7 +120,17 @@ export function registerBuiltinAttributes(meta) {
                 if (config.prefix) {
                     return core.prefixed({ prefix: config.prefix, child: resourceLocation })(src, ctx);
                 }
-                return resourceLocation(src, ctx);
+                const node = resourceLocation(src, ctx);
+                if (config.exclude) {
+                    const resourceLocation = core.ResourceLocationNode.toString(node, 'full');
+                    for (const e of config.exclude ?? []) {
+                        const excluded = core.ResourceLocation.lengthen(e);
+                        if (resourceLocation === excluded) {
+                            ctx.err.report(localize('not-allowed-here', localeQuote(excluded)), node, 2 /* core.ErrorSeverity.Warning */);
+                        }
+                    }
+                }
+                return node;
             };
         },
         stringMocker: (config, typeDef, ctx) => {
@@ -202,5 +210,25 @@ export function registerBuiltinAttributes(meta) {
             };
         },
     });
+    registerAttribute(meta, 'regex_pattern', () => undefined, {
+        checker: (_, typeDef) => {
+            if (typeDef.kind !== 'literal' || typeDef.value.kind !== 'string') {
+                return undefined;
+            }
+            const pattern = typeDef.value.value;
+            return (node, ctx) => {
+                try {
+                    RegExp(pattern);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : `${e}`;
+                    const error = message
+                        .replace(/^Invalid regular expression: /, '')
+                        .replace(/^\/.+\/: /, '');
+                    ctx.err.report(localize('invalid-regex-pattern', error), node, 2);
+                }
+            };
+        },
+    });
 }
 //# sourceMappingURL=builtin.js.map

package/lib/runtime/attribute/validator.d.ts

@@ -10,6 +10,7 @@ export declare function tree<C extends {
 }>(properties: {
     [K in keyof C]: McdocAttributeValidator<C[K]>;
 }): McdocAttributeValidator<C>;
+export declare function list<C extends core.Returnable>(itemValidator: McdocAttributeValidator<C>): McdocAttributeValidator<C[]>;
 export declare function optional<C extends core.Returnable>(validator: McdocAttributeValidator<C>): McdocAttributeValidator<C | undefined>;
 export declare function map<C extends core.Returnable, D extends core.Returnable>(validator: McdocAttributeValidator<C>, mapper: (value: C) => D | typeof core.Failure): McdocAttributeValidator<D>;
 export declare function alternatives<C extends core.Returnable>(...validators: McdocAttributeValidator<C>[]): McdocAttributeValidator<C>;

package/lib/runtime/attribute/validator.js

@@ -59,6 +59,22 @@ export function tree(properties) {
         return result;
     };
 }
+export function list(itemValidator) {
+    return (value, ctx) => {
+        if (value?.kind !== 'tree') {
+            return core.Failure;
+        }
+        const result = [];
+        for (const element of Object.values(value.values)) {
+            const item = itemValidator(element, ctx);
+            if (item === core.Failure) {
+                return core.Failure;
+            }
+            result.push(item);
+        }
+        return result;
+    };
+}
 export function optional(validator) {
     return (value, ctx) => {
         const config = validator(value, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcdoc",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.13",
-    "@spyglassmc/locales": "0.3.8"
+    "@spyglassmc/core": "0.4.15",
+    "@spyglassmc/locales": "0.3.9"
   }
 }