npm - @spyglassmc/mcdoc - Versions diffs - 0.3.1 → 0.3.3 - Mend

@spyglassmc/mcdoc 0.3.1 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/lib/type/index.d.ts CHANGED Viewed

@@ -4,20 +4,20 @@ export interface Attribute {
     name: string;
     value?: AttributeValue;
 }
-export declare type AttributeValue = McdocType | {
+export type AttributeValue = McdocType | {
     kind: 'tree';
     values: AttributeTree;
 };
-export declare type AttributeTree = {
+export type AttributeTree = {
     [key: string | number]: AttributeValue;
 };
-export declare type NumericRange = {
+export type NumericRange = {
     kind: RangeKind;
     min?: number;
     max?: number;
 };
 export declare const StaticIndexKeywords: readonly ["fallback", "none", "unknown"];
-export declare type StaticIndexKeyword = typeof StaticIndexKeywords[number];
+export type StaticIndexKeyword = (typeof StaticIndexKeywords)[number];
 export interface StaticIndex {
     kind: 'static';
     value: string;
@@ -28,28 +28,23 @@ export interface DynamicIndex {
         keyword: 'key' | 'parent';
     })[];
 }
-export declare type Index = StaticIndex | DynamicIndex;
+export type Index = StaticIndex | DynamicIndex;
 /**
  * Corresponds to the IndexBodyNode
  */
-export declare type ParallelIndices = Index[];
+export type ParallelIndices = Index[];
 export interface DispatcherData {
     registry: FullResourceLocation;
-    index: ParallelIndices;
+    parallelIndices: ParallelIndices;
 }
-export interface TypeBase {
-    kind: string;
-    attributes?: Attribute[];
-    indices?: ParallelIndices[];
-}
-export interface DispatcherType extends TypeBase, DispatcherData {
+export interface DispatcherType extends DispatcherData {
     kind: 'dispatcher';
 }
-export interface StructType extends TypeBase {
+export interface StructType {
     kind: 'struct';
     fields: StructTypeField[];
 }
-export declare type StructTypeField = StructTypePairField | StructTypeSpreadField;
+export type StructTypeField = StructTypePairField | StructTypeSpreadField;
 export interface StructTypePairField {
     kind: 'pair';
     attributes?: Attribute[];
@@ -62,7 +57,7 @@ export interface StructTypeSpreadField {
     attributes?: Attribute[];
     type: McdocType;
 }
-export interface EnumType extends TypeBase {
+export interface EnumType {
     kind: 'enum';
     enumKind?: EnumKind;
     values: EnumTypeField[];
@@ -72,25 +67,46 @@ export interface EnumTypeField {
     identifier: string;
     value: string | number | bigint;
 }
-export interface ReferenceType extends TypeBase {
+export interface ReferenceType {
     kind: 'reference';
     path?: string;
-    typeParameters?: McdocType[];
 }
-export interface UnionType<T extends McdocType = McdocType> extends TypeBase {
+export interface UnionType<T extends McdocType = McdocType> {
     kind: 'union';
     members: T[];
 }
+export interface AttributedType {
+    kind: 'attributed';
+    attribute: Attribute;
+    child: McdocType;
+}
+export interface IndexedType {
+    kind: 'indexed';
+    parallelIndices: Index[];
+    child: McdocType;
+}
+export interface TemplateType {
+    kind: 'template';
+    child: McdocType;
+    typeParams: {
+        path: string;
+    }[];
+}
+export interface ConcreteType {
+    kind: 'concrete';
+    child: McdocType;
+    typeArgs: McdocType[];
+}
 export declare const EmptyUnion: UnionType<never> & NoIndices;
 export declare function createEmptyUnion(attributes?: Attribute[]): UnionType<never> & NoIndices;
-export interface KeywordType extends TypeBase {
-    kind: 'any' | 'boolean';
+export interface KeywordType {
+    kind: 'any' | 'boolean' | 'unsafe';
 }
-export interface StringType extends TypeBase {
+export interface StringType {
     kind: 'string';
     lengthRange?: NumericRange;
 }
-export declare type LiteralValue = {
+export type LiteralValue = {
     kind: 'boolean';
     value: boolean;
 } | {
@@ -101,66 +117,66 @@ export declare type LiteralValue = {
     value: number;
     suffix: 'b' | 's' | 'l' | 'f' | 'd' | undefined;
 };
-export interface LiteralType extends TypeBase {
+export interface LiteralType {
     kind: 'literal';
     value: LiteralValue;
 }
 export declare const LiteralNumberSuffixes: readonly ["b", "s", "l", "f", "d"];
-export declare type LiteralNumberSuffix = typeof LiteralNumberSuffixes[number];
+export type LiteralNumberSuffix = (typeof LiteralNumberSuffixes)[number];
 export declare const LiteralNumberCaseInsensitiveSuffixes: readonly ["b", "s", "l", "f", "d", "B", "S", "L", "F", "D"];
-export declare type LiteralNumberCaseInsensitiveSuffix = typeof LiteralNumberCaseInsensitiveSuffixes[number];
-export interface NumericType extends TypeBase {
+export type LiteralNumberCaseInsensitiveSuffix = (typeof LiteralNumberCaseInsensitiveSuffixes)[number];
+export interface NumericType {
     kind: NumericTypeKind;
     valueRange?: NumericRange;
 }
 export declare const NumericTypeIntKinds: readonly ["byte", "short", "int", "long"];
-export declare type NumericTypeIntKind = typeof NumericTypeIntKinds[number];
+export type NumericTypeIntKind = (typeof NumericTypeIntKinds)[number];
 export declare const NumericTypeFloatKinds: readonly ["float", "double"];
-export declare type NumericTypeFloatKind = typeof NumericTypeFloatKinds[number];
+export type NumericTypeFloatKind = (typeof NumericTypeFloatKinds)[number];
 export declare const NumericTypeKinds: readonly ["byte", "short", "int", "long", "float", "double"];
-export declare type NumericTypeKind = typeof NumericTypeKinds[number];
-export interface PrimitiveArrayType extends TypeBase {
+export type NumericTypeKind = (typeof NumericTypeKinds)[number];
+export interface PrimitiveArrayType {
     kind: 'byte_array' | 'int_array' | 'long_array';
     valueRange?: NumericRange;
     lengthRange?: NumericRange;
 }
 export declare const PrimitiveArrayValueKinds: readonly ["byte", "int", "long"];
-export declare type PrimitiveArrayValueKind = typeof PrimitiveArrayValueKinds[number];
+export type PrimitiveArrayValueKind = (typeof PrimitiveArrayValueKinds)[number];
 export declare const PrimitiveArrayKinds: readonly ("byte_array" | "int_array" | "long_array")[];
-export declare type PrimitiveArrayKind = typeof PrimitiveArrayKinds[number];
-export interface ListType extends TypeBase {
+export type PrimitiveArrayKind = (typeof PrimitiveArrayKinds)[number];
+export interface ListType {
     kind: 'list';
     item: McdocType;
     lengthRange?: NumericRange;
 }
-export interface TupleType extends TypeBase {
+export interface TupleType {
     kind: 'tuple';
     items: McdocType[];
 }
-export declare type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType;
+export type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType | AttributedType | IndexedType | TemplateType | ConcreteType;
 export declare namespace McdocType {
     function toString(type: McdocType | undefined): string;
 }
 /**
  * A type that doesn't include a dispatcher type.
  */
-export declare type DispatchedType = Exclude<McdocType, DispatcherType | UnionType> | UnionType<DispatchedType>;
+export type DispatchedType = Exclude<McdocType, DispatcherType | UnionType> | UnionType<DispatchedType>;
 /**
  * A type that doesn't include a reference type.
  */
-export declare type DereferencedType = Exclude<McdocType, ReferenceType | UnionType> | UnionType<DereferencedType>;
+export type DereferencedType = Exclude<McdocType, ReferenceType | UnionType> | UnionType<DereferencedType>;
 /**
  * A type that doesn't include a dispatcher type or a reference type.
  */
-export declare type TangibleType = Exclude<McdocType, DispatcherType | ReferenceType | UnionType> | UnionType<TangibleType>;
+export type TangibleType = Exclude<McdocType, DispatcherType | ReferenceType | UnionType> | UnionType<TangibleType>;
 /**
  * A type that is {@link TangibleType} and doesn't have any indices.
  */
-export declare type ResolvedType = (Exclude<McdocType, DispatcherType | ReferenceType | UnionType> | UnionType<ResolvedType>) & NoIndices;
-declare type NoIndices = {
+export type ResolvedType = (Exclude<McdocType, DispatcherType | ReferenceType | UnionType> | UnionType<ResolvedType>) & NoIndices;
+type NoIndices = {
     indices?: undefined;
 };
-export interface FlatStructType extends TypeBase {
+export interface FlatStructType {
     kind: 'flat_struct';
     fields: Record<string, McdocType>;
 }
@@ -169,7 +185,7 @@ export declare const unionTypes: (a: McdocType, b: McdocType) => McdocType;
 export declare const simplifyUnionType: (union: UnionType) => McdocType;
 export declare const simplifyListType: (list: ListType) => ListType;
 export declare const simplifyType: (data: McdocType) => McdocType;
-export declare const checkAssignability: ({ source, target }: {
+export declare const checkAssignability: ({ source, target, }: {
     source: McdocType | undefined;
     target: McdocType | undefined;
 }) => {

package/lib/type/index.js CHANGED Viewed

@@ -1,21 +1,53 @@
-import { Arrayable } from '@spyglassmc/core';
+import { Arrayable, Dev } from '@spyglassmc/core';
 import { localeQuote, localize } from '@spyglassmc/locales';
 import { getRangeDelimiter } from '../node/index.js';
-export const StaticIndexKeywords = Object.freeze(['fallback', 'none', 'unknown']);
-export const EmptyUnion = Object.freeze({ kind: 'union', members: [] });
+export const StaticIndexKeywords = Object.freeze([
+    'fallback',
+    'none',
+    'unknown',
+]);
+export const EmptyUnion = Object.freeze({
+    kind: 'union',
+    members: [],
+});
 export function createEmptyUnion(attributes) {
     return {
         ...EmptyUnion,
-        attributes,
+        // attributes,
     };
 }
-export const LiteralNumberSuffixes = Object.freeze(['b', 's', 'l', 'f', 'd']);
-export const LiteralNumberCaseInsensitiveSuffixes = Object.freeze([...LiteralNumberSuffixes, 'B', 'S', 'L', 'F', 'D']);
-export const NumericTypeIntKinds = Object.freeze(['byte', 'short', 'int', 'long']);
+export const LiteralNumberSuffixes = Object.freeze([
+    'b',
+    's',
+    'l',
+    'f',
+    'd',
+]);
+export const LiteralNumberCaseInsensitiveSuffixes = Object.freeze([
+    ...LiteralNumberSuffixes,
+    'B',
+    'S',
+    'L',
+    'F',
+    'D',
+]);
+export const NumericTypeIntKinds = Object.freeze([
+    'byte',
+    'short',
+    'int',
+    'long',
+]);
 export const NumericTypeFloatKinds = Object.freeze(['float', 'double']);
-export const NumericTypeKinds = Object.freeze([...NumericTypeIntKinds, ...NumericTypeFloatKinds]);
-export const PrimitiveArrayValueKinds = Object.freeze(['byte', 'int', 'long']);
-export const PrimitiveArrayKinds = Object.freeze(PrimitiveArrayValueKinds.map(kind => `${kind}_array`));
+export const NumericTypeKinds = Object.freeze([
+    ...NumericTypeIntKinds,
+    ...NumericTypeFloatKinds,
+]);
+export const PrimitiveArrayValueKinds = Object.freeze([
+    'byte',
+    'int',
+    'long',
+]);
+export const PrimitiveArrayKinds = Object.freeze(PrimitiveArrayValueKinds.map((kind) => `${kind}_array`));
 export var McdocType;
 (function (McdocType) {
     function toString(type) {
@@ -24,7 +56,9 @@ export var McdocType;
                 return '';
             }
             const { kind, min, max } = range;
-            return min === max ? ` @ ${min}` : ` @ ${min ?? ''}${getRangeDelimiter(kind)}${max ?? ''}`;
+            return min === max
+                ? ` @ ${min}`
+                : ` @ ${min ?? ''}${getRangeDelimiter(kind)}${max ?? ''}`;
         };
         const indicesToString = (indices) => {
             const strings = [];
@@ -35,7 +69,9 @@ export var McdocType;
                 else {
                     strings.push(index.kind === 'static'
                         ? `[${index.value}]`
-                        : `[[${index.accessor.map(v => typeof v === 'string' ? v : v.keyword).join('.')}]]`);
+                        : `[[${index.accessor
+                            .map((v) => (typeof v === 'string' ? v : v.keyword))
+                            .join('.')}]]`);
                 }
             }
             return `[${strings.join(', ')}]`;
@@ -47,18 +83,26 @@ export var McdocType;
             case 'any':
             case 'boolean':
                 return type.kind;
+            case 'attributed':
+                return `#[${type.attribute.name}${type.attribute.value ? '=<value ...>' : ''}] ${toString(type.child)}`;
             case 'byte':
                 return `byte${rangeToString(type.valueRange)}`;
             case 'byte_array':
                 return `byte${rangeToString(type.valueRange)}[]${rangeToString(type.lengthRange)}`;
+            case 'concrete':
+                return `${toString(type.child)}${type.typeArgs.length
+                    ? `<${type.typeArgs.map(toString).join(', ')}>`
+                    : ''}`;
             case 'dispatcher':
-                return `${type.registry ?? 'spyglass:unknown'}[${indicesToString(type.index)}]`;
+                return `${type.registry ?? 'spyglass:unknown'}[${indicesToString(type.parallelIndices)}]`;
             case 'double':
                 return `double${rangeToString(type.valueRange)}`;
             case 'enum':
-                return '<anonymous_enum>';
+                return '<enum ...>';
             case 'float':
                 return `float${rangeToString(type.valueRange)}`;
+            case 'indexed':
+                return `${toString(type.child)}${indicesToString(type.parallelIndices)}`;
             case 'int':
                 return `int${rangeToString(type.valueRange)}`;
             case 'int_array':
@@ -78,11 +122,19 @@ export var McdocType;
             case 'string':
                 return `string${rangeToString(type.lengthRange)}`;
             case 'struct':
-                return '<anonymous_compound>';
+                return '<struct ...>';
+            case 'template':
+                return `${toString(type.child)}${type.typeParams.length
+                    ? `<${type.typeParams.map((v) => `?${v.path}`).join(', ')}>`
+                    : ''}`;
             case 'tuple':
-                return `[${type.items.map(v => toString(v)).join(',')}${type.items.length === 1 ? ',' : ''}]`;
+                return `[${type.items.map((v) => toString(v)).join(',')}${type.items.length === 1 ? ',' : ''}]`;
             case 'union':
                 return `(${type.members.map(toString).join(' | ')})`;
+            case 'unsafe':
+                return 'unsafe';
+            default:
+                return Dev.assertNever(type);
         }
     }
     McdocType.toString = toString;
@@ -102,17 +154,19 @@ const areRangesMatch = (s, t) => {
     }
     const { min: sMin, max: sMax } = s;
     const { min: tMin, max: tMax } = t;
-    return (tMin === undefined || (sMin !== undefined && sMin >= tMin)) &&
-        (tMax === undefined || (sMax !== undefined && sMax <= tMax));
+    return ((tMin === undefined || (sMin !== undefined && sMin >= tMin)) &&
+        (tMax === undefined || (sMax !== undefined && sMax <= tMax)));
 };
 export const flattenUnionType = (union) => {
     const set = new Set();
     const add = (data) => {
         for (const existingMember of set) {
-            if ((check(data, existingMember) & CheckResult.StrictlyAssignable) === CheckResult.StrictlyAssignable) {
+            if ((check(data, existingMember) & CheckResult.StrictlyAssignable) ===
+                CheckResult.StrictlyAssignable) {
                 return;
             }
-            if ((check(existingMember, data) & CheckResult.StrictlyAssignable) === CheckResult.StrictlyAssignable) {
+            if ((check(existingMember, data) & CheckResult.StrictlyAssignable) ===
+                CheckResult.StrictlyAssignable) {
                 set.delete(existingMember);
             }
         }
@@ -132,17 +186,19 @@ export const flattenUnionType = (union) => {
     };
 };
 export const unionTypes = (a, b) => {
-    if ((check(a, b) & CheckResult.StrictlyAssignable) === CheckResult.StrictlyAssignable) {
+    if ((check(a, b) & CheckResult.StrictlyAssignable) ===
+        CheckResult.StrictlyAssignable) {
         return b;
     }
-    if ((check(b, a) & CheckResult.StrictlyAssignable) === CheckResult.StrictlyAssignable) {
+    if ((check(b, a) & CheckResult.StrictlyAssignable) ===
+        CheckResult.StrictlyAssignable) {
         return a;
     }
     const ans = {
         kind: 'union',
         members: [
-            ...a.kind === 'union' ? a.members : [a],
-            ...b.kind === 'union' ? b.members : [b],
+            ...(a.kind === 'union' ? a.members : [a]),
+            ...(b.kind === 'union' ? b.members : [b]),
         ],
     };
     return ans;
@@ -157,7 +213,7 @@ export const simplifyUnionType = (union) => {
 export const simplifyListType = (list) => ({
     kind: 'list',
     item: simplifyType(list.item),
-    ...list.lengthRange ? { lengthRange: { ...list.lengthRange } } : {},
+    ...(list.lengthRange ? { lengthRange: { ...list.lengthRange } } : {}),
 });
 export const simplifyType = (data) => {
     if (data.kind === 'union') {
@@ -182,10 +238,10 @@ const check = (s, t, errors = []) => {
         ans = CheckResult.StrictlyAssignable;
     }
     else if (s.kind === 'union') {
-        ans = assignableIfTrue(s.members.every(v => check(v, t, errors)));
+        ans = assignableIfTrue(s.members.every((v) => check(v, t, errors)));
     }
     else if (t.kind === 'union') {
-        ans = assignableIfTrue(t.members.some(v => check(s, v)));
+        ans = assignableIfTrue(t.members.some((v) => check(s, v)));
     }
     else if (s.kind === 'boolean') {
         ans = strictlyAssignableIfTrue(t.kind === 'boolean' || t.kind === 'byte');
@@ -204,16 +260,31 @@ const check = (s, t, errors = []) => {
             ans = CheckResult.Nah;
         }
     }
-    else if (s.kind === 'byte_array' || s.kind === 'int_array' || s.kind === 'long_array') {
-        ans = strictlyAssignableIfTrue(t.kind === s.kind && areRangesMatch(s.lengthRange, t.lengthRange) && areRangesMatch(s.valueRange, t.valueRange));
+    else if (s.kind === 'byte_array' ||
+        s.kind === 'int_array' ||
+        s.kind === 'long_array') {
+        ans = strictlyAssignableIfTrue(t.kind === s.kind &&
+            areRangesMatch(s.lengthRange, t.lengthRange) &&
+            areRangesMatch(s.valueRange, t.valueRange));
     }
     else if (s.kind === 'struct' || s.kind === 'dispatcher') {
         ans = assignableIfTrue(t.kind === 'struct' || t.kind === 'dispatcher');
     }
     else if (s.kind === 'enum') {
-        ans = assignableIfTrue((t.kind === 'byte' || t.kind === 'float' || t.kind === 'double' || t.kind === 'int' || t.kind === 'long' || t.kind === 'short' || t.kind === 'string') && (!s.enumKind || s.enumKind === t.kind));
-    }
-    else if (s.kind === 'float' || s.kind === 'double' || s.kind === 'int' || s.kind === 'long' || s.kind === 'short') {
+        ans = assignableIfTrue((t.kind === 'byte' ||
+            t.kind === 'float' ||
+            t.kind === 'double' ||
+            t.kind === 'int' ||
+            t.kind === 'long' ||
+            t.kind === 'short' ||
+            t.kind === 'string') &&
+            (!s.enumKind || s.enumKind === t.kind));
+    }
+    else if (s.kind === 'float' ||
+        s.kind === 'double' ||
+        s.kind === 'int' ||
+        s.kind === 'long' ||
+        s.kind === 'short') {
         if (t.kind === s.kind) {
             ans = strictlyAssignableIfTrue(areRangesMatch(s.valueRange, t.valueRange));
         }
@@ -248,7 +319,7 @@ const check = (s, t, errors = []) => {
     }
     return ans;
 };
-export const checkAssignability = ({ source, target }) => {
+export const checkAssignability = ({ source, target, }) => {
     if (source === undefined || target === undefined) {
         return { isAssignable: true };
     }
@@ -256,17 +327,24 @@ export const checkAssignability = ({ source, target }) => {
     check(source, target, errors);
     return {
         isAssignable: errors.length === 0,
-        ...errors.length ? { errorMessage: errors.reverse().map((m, i) => `${'  '.repeat(i)}${m}`).join('\n') } : {},
+        ...(errors.length
+            ? {
+                errorMessage: errors
+                    .reverse()
+                    .map((m, i) => `${'  '.repeat(i)}${m}`)
+                    .join('\n'),
+            }
+            : {}),
     };
 };
 export function resolveType(inputType, ctx, value) {
     const type = getTangibleType(inputType, ctx, value);
-    let ans = (() => {
+    const ans = (() => {
         if (type.kind === 'union') {
             return {
                 kind: 'union',
-                members: type.members.map(t => resolveType(t, ctx, value)),
-                attributes: type.attributes,
+                members: type.members.map((t) => resolveType(t, ctx, value)),
+                // attributes: type.attributes,
             };
         }
         else {
@@ -276,9 +354,9 @@ export function resolveType(inputType, ctx, value) {
             };
         }
     })();
-    for (const parallelIndices of type.indices ?? []) {
-        ans = navigateParallelIndices(ans, parallelIndices, ctx, value);
-    }
+    // for (const parallelIndices of type.indices ?? []) {
+    // 	ans = navigateParallelIndices(ans, parallelIndices, ctx, value)
+    // }
     return ans;
 }
 function dispatchType(type, ctx) {
@@ -298,7 +376,7 @@ function getTangibleType(type, ctx, value) {
         return getTangibleType(dereferencedType, ctx, value);
     }
     else if (type.kind === 'union') {
-        ans = mapUnion(type, t => getTangibleType(t, ctx, value));
+        ans = mapUnion(type, (t) => getTangibleType(t, ctx, value));
     }
     else {
         ans = type;
@@ -312,27 +390,31 @@ function navigateParallelIndices(type, indices, ctx, value) {
     else {
         return {
             kind: 'union',
-            members: indices.map(i => navigateIndex(type, i, ctx, value)),
-            attributes: type.attributes,
+            members: indices.map((i) => navigateIndex(type, i, ctx, value)),
+            // attributes: type.attributes,
         };
     }
 }
 function navigateIndex(type, index, ctx, value) {
     if (type.kind === 'struct') {
         const key = index.kind === 'static'
-            ? typeof index.value === 'string' ? index.value : undefined // Special static indices have no meaning on structs.
+            ? typeof index.value === 'string'
+                ? index.value
+                : undefined // Special static indices have no meaning on structs.
             : resolveDynamicIndex(index, value);
         if (key === undefined) {
-            return createEmptyUnion(type.attributes);
+            // return createEmptyUnion(type.attributes)
+            return createEmptyUnion();
         }
         const flatStruct = flattenStruct(type, ctx, value);
         return resolveType(flatStruct.fields[key], ctx, value);
     }
     else if (type.kind === 'union') {
-        return mapUnion(type, t => navigateIndex(t, index, ctx, value));
+        return mapUnion(type, (t) => navigateIndex(t, index, ctx, value));
     }
     else {
-        return createEmptyUnion(type.attributes);
+        // return createEmptyUnion(type.attributes)
+        return createEmptyUnion();
     }
 }
 function resolveDynamicIndex(index, value) {
@@ -356,8 +438,8 @@ function mapUnion(type, mapper) {
     const ans = {
         kind: 'union',
         members: type.members.map(mapper),
-        attributes: type.attributes,
-        indices: type.indices,
+        // attributes: type.attributes,
+        // indices: type.indices,
     };
     return ans;
 }
@@ -365,13 +447,13 @@ function flattenStruct(type, ctx, value) {
     const ans = {
         kind: 'flat_struct',
         fields: Object.create(null),
-        attributes: type.attributes,
-        indices: type.indices,
+        // attributes: type.attributes,
+        // indices: type.indices,
     };
     for (const field of type.fields) {
         if (field.kind === 'spread') {
             const target = resolveType(field.type, ctx, value);
-            addAttributes(ans, ...target.attributes ?? []);
+            // addAttributes(ans, ...target.attributes ?? [])
             if (target.kind === 'struct') {
                 const flatTarget = flattenStruct(target, ctx, value);
                 for (const [key, value] of Object.entries(flatTarget)) {
@@ -392,10 +474,10 @@ function flattenStruct(type, ctx, value) {
 }
 function addAttributes(type, ...attributes) {
     for (const attr of attributes) {
-        type.attributes ??= [];
-        if (!type.attributes.some(a => a.name === attr.name)) {
-            type.attributes.push(attr);
-        }
+        // type.attributes ??= []
+        // if (!type.attributes.some(a => a.name === attr.name)) {
+        // 	type.attributes.push(attr)
+        // }
     }
 }
 //# sourceMappingURL=index.js.map

package/lib/uri_processors.js CHANGED Viewed

@@ -12,9 +12,7 @@ export const uriBinder = (uris, ctx) => {
         if (!rel) {
             continue;
         }
-        rel = rel
-            .slice(0, -Extension.length)
-            .replace(/(^|\/)mod$/, '');
+        rel = rel.slice(0, -Extension.length).replace(/(^|\/)mod$/, '');
         urisAndRels.push([uri, rel]);
     }
     // Now the value of `urisAndRels`:
@@ -23,8 +21,10 @@ export const uriBinder = (uris, ctx) => {
     // A special check for the directory named `mcdoc`:
     // If all files are put under this folder, we will treat that folder as the "root" instead.
     if (urisAndRels.every(([_, rel]) => rel.startsWith(McdocRootPrefix))) {
-        urisAndRels = urisAndRels
-            .map(([uri, rel]) => [uri, rel.slice(McdocRootPrefix.length)]);
+        urisAndRels = urisAndRels.map(([uri, rel]) => [
+            uri,
+            rel.slice(McdocRootPrefix.length),
+        ]);
     }
     // Now the value of `urisAndRels`:
     // file:///root/mcdoc/foo/mod.mcdoc -> foo

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcdoc",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "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.0",
-    "@spyglassmc/locales": "0.3.0"
+    "@spyglassmc/core": "0.4.2",
+    "@spyglassmc/locales": "0.3.2"
   }
 }