@spyglassmc/mcdoc 0.3.7 → 0.3.9

package/lib/runtime/completer/index.d.ts

@@ -0,0 +1,20 @@
+import type * as core from '@spyglassmc/core';
+import type { McdocType, StructTypePairField } from '../../type/index.js';
+import type { SimplifiedMcdocType } from '../checker/index.js';
+export type SimpleCompletionField = {
+    key: string;
+    field: core.DeepReadonly<StructTypePairField>;
+};
+export interface McdocCompleterContext extends core.CompleterContext {
+    requireCanonical?: boolean;
+}
+export declare function getFields(typeDef: core.DeepReadonly<SimplifiedMcdocType>, ctx: McdocCompleterContext): SimpleCompletionField[];
+export type SimpleCompletionValue = {
+    value: string;
+    detail?: string;
+    kind?: McdocType['kind'];
+    completionKind?: core.CompletionKind;
+    insertText?: string;
+};
+export declare function getValues(typeDef: core.DeepReadonly<McdocType>, ctx: McdocCompleterContext): SimpleCompletionValue[];
+//# sourceMappingURL=index.d.ts.map

package/lib/runtime/completer/index.js

@@ -0,0 +1,123 @@
+import { TypeDefSymbolData } from '../../binder/index.js';
+import { handleAttributes } from '../attribute/index.js';
+export function getFields(typeDef, ctx) {
+    switch (typeDef.kind) {
+        case 'union':
+            const allFields = new Map();
+            for (const member of typeDef.members) {
+                for (const field of getFields(member, ctx)) {
+                    allFields.set(field.key, field);
+                }
+            }
+            return [...allFields.values()];
+        case 'struct':
+            return typeDef.fields.flatMap(field => {
+                if (typeof field.key === 'string') {
+                    return [{ key: field.key, field }];
+                }
+                if (field.key.kind === 'string'
+                    || (field.key.kind === 'literal' && field.key.value.kind === 'string')
+                    || (field.key.kind === 'enum' && field.key.enumKind === 'string')) {
+                    const ans = getStringCompletions(field.key, ctx);
+                    if (ans.length > 0) {
+                        return ans.map(c => ({ key: c.value, field }));
+                    }
+                }
+                if (field.key.kind === 'literal') {
+                    return [{ key: `${field.key.value.value}`, field }];
+                }
+                if (field.key.kind === 'string') {
+                    return getStringCompletions(field.key, ctx)
+                        .map(c => ({ key: c.value, field }));
+                }
+                return [];
+            });
+        default:
+            return [];
+    }
+}
+// TODO: only accept SimplifiedMcdocType here
+export function getValues(typeDef, ctx) {
+    if (typeDef.kind === 'string'
+        || (typeDef.kind === 'literal' && typeDef.value.kind === 'string')
+        || (typeDef.kind === 'enum' && typeDef.enumKind === 'string')) {
+        const ans = getStringCompletions(typeDef, ctx);
+        if (ans.length > 0) {
+            return ans;
+        }
+    }
+    switch (typeDef.kind) {
+        case 'union':
+            const allValues = new Map();
+            for (const member of typeDef.members) {
+                for (const value of getValues(member, ctx)) {
+                    allValues.set(value.value, value);
+                }
+            }
+            return [...allValues.values()];
+        case 'reference':
+            // TODO: de-duplicate this logic from the runtime simplifier
+            if (!typeDef.path) {
+                return [];
+            }
+            const symbol = ctx.symbols.query(ctx.doc, 'mcdoc', typeDef.path);
+            const def = symbol.getData(TypeDefSymbolData.is)?.typeDef;
+            if (!def) {
+                return [];
+            }
+            if (typeDef.attributes?.length) {
+                return getValues({
+                    ...def,
+                    attributes: [...typeDef.attributes, ...def.attributes ?? []],
+                }, ctx);
+            }
+            return getValues(def, ctx);
+        case 'literal':
+            return [{ value: `${typeDef.value.value}`, kind: typeDef.value.kind }];
+        case 'boolean':
+            return ['false', 'true'].map(v => ({ value: v, kind: 'boolean' }));
+        case 'enum':
+            // TODO: de-duplicate this logic from the runtime simplifier
+            const filteredValues = typeDef.values.filter(value => {
+                let keep = true;
+                handleAttributes(value.attributes, ctx, (handler, config) => {
+                    if (!keep || !handler.filterElement) {
+                        return;
+                    }
+                    if (!handler.filterElement(config, ctx)) {
+                        keep = false;
+                    }
+                });
+                return keep;
+            });
+            return filteredValues.map(v => ({
+                value: `${v.value}`,
+                detail: v.identifier,
+                kind: typeDef.enumKind ?? 'string',
+            }));
+        default:
+            return [];
+    }
+}
+function getStringCompletions(typeDef, ctx) {
+    const ans = [];
+    handleAttributes(typeDef.attributes, ctx, (handler, config) => {
+        const mock = handler.stringMocker?.(config, typeDef, ctx);
+        if (!mock) {
+            return;
+        }
+        const items = ctx.meta.getCompleter(mock.type)(mock, ctx);
+        ans.push(...items.map(item => ({
+            value: item.label,
+            kind: 'string',
+            detail: item.detail,
+            completionKind: item.kind,
+            insertText: item.insertText,
+        })));
+    });
+    if (ans.length === 0 && typeDef.kind === 'literal') {
+        ans.push({ value: `${typeDef.value.value}`, kind: 'string' });
+    }
+    return ans;
+}
+//# sourceMappingURL=index.js.map

package/lib/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { McdocAttribute, registerAttribute } from './attribute/index.js';
+export * as attribute from './attribute/index.js';
+export * as checker from './checker/index.js';
+export * as completer from './completer/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/runtime/index.js

@@ -0,0 +1,5 @@
+export { registerAttribute } from './attribute/index.js';
+export * as attribute from './attribute/index.js';
+export * as checker from './checker/index.js';
+export * as completer from './completer/index.js';
+//# sourceMappingURL=index.js.map

package/lib/type/index.d.ts

@@ -1,21 +1,39 @@
-import type { FullResourceLocation, ProcessorContext } from '@spyglassmc/core';
-import type { EnumKind, RangeKind } from '../node/index.js';
+import type { FullResourceLocation } from '@spyglassmc/core';
+import type { EnumKind } from '../node/index.js';
+import { RangeKind } from '../node/index.js';
+export type Attributes = Attribute[];
+export declare namespace Attributes {
+    function equals(a: Attributes | undefined, b: Attributes | undefined): boolean;
+}
 export interface Attribute {
     name: string;
     value?: AttributeValue;
 }
-export type AttributeValue = McdocType | {
+export declare namespace Attribute {
+    function equals(a: Attribute, b: Attribute): boolean;
+}
+export type AttributeValue = McdocType | AttributeTreeValue;
+export interface AttributeTreeValue {
     kind: 'tree';
     values: AttributeTree;
-};
-export type AttributeTree = {
+}
+export interface AttributeTree {
     [key: string | number]: AttributeValue;
-};
+}
+export declare namespace AttributeValue {
+    function equals(a: AttributeValue, b: AttributeValue): boolean;
+}
 export type NumericRange = {
     kind: RangeKind;
     min?: number;
     max?: number;
 };
+export declare namespace NumericRange {
+    function isInRange(range: NumericRange, val: number): boolean;
+    function equals(a: NumericRange, b: NumericRange): boolean;
+    function intersect(a: NumericRange, b: NumericRange): NumericRange;
+    function toString({ kind, min, max }: NumericRange): string;
+}
 export declare const StaticIndexKeywords: readonly ["fallback", "none", "unknown", "spawnitem", "blockitem"];
 export type StaticIndexKeyword = (typeof StaticIndexKeywords)[number];
 export interface StaticIndex {
@@ -33,99 +51,101 @@ export type Index = StaticIndex | DynamicIndex;
  * Corresponds to the IndexBodyNode
  */
 export type ParallelIndices = Index[];
+export declare namespace ParallelIndices {
+    function equals(a: ParallelIndices, b: ParallelIndices): boolean;
+}
 export interface DispatcherData {
     registry: FullResourceLocation;
     parallelIndices: ParallelIndices;
 }
-export interface DispatcherType extends DispatcherData {
+export interface DispatcherType extends DispatcherData, McdocBaseType {
     kind: 'dispatcher';
 }
-export interface StructType {
+export interface StructType extends McdocBaseType {
     kind: 'struct';
     fields: StructTypeField[];
 }
 export type StructTypeField = StructTypePairField | StructTypeSpreadField;
-export interface StructTypePairField {
+export interface StructTypePairField extends McdocBaseType {
     kind: 'pair';
-    attributes?: Attribute[];
     key: string | McdocType;
     type: McdocType;
     optional?: boolean;
+    deprecated?: boolean;
+    desc?: string;
 }
-export interface StructTypeSpreadField {
+export interface StructTypeSpreadField extends McdocBaseType {
     kind: 'spread';
-    attributes?: Attribute[];
     type: McdocType;
 }
-export interface EnumType {
+export interface EnumType extends McdocBaseType {
     kind: 'enum';
     enumKind?: EnumKind;
     values: EnumTypeField[];
 }
-export interface EnumTypeField {
-    attributes?: Attribute[];
+export interface EnumTypeField extends McdocBaseType {
     identifier: string;
-    value: string | number | bigint;
+    value: string | number;
 }
-export interface ReferenceType {
+export interface ReferenceType extends McdocBaseType {
     kind: 'reference';
     path?: string;
 }
-export interface UnionType<T extends McdocType = McdocType> {
+export interface UnionType<T extends McdocType = McdocType> extends McdocBaseType {
     kind: 'union';
     members: T[];
 }
-export interface AttributedType {
-    kind: 'attributed';
-    attribute: Attribute;
-    child: McdocType;
-}
-export interface IndexedType {
+export interface IndexedType extends McdocBaseType {
     kind: 'indexed';
     parallelIndices: Index[];
     child: McdocType;
 }
-export interface TemplateType {
+export interface TemplateType extends McdocBaseType {
     kind: 'template';
     child: McdocType;
     typeParams: {
         path: string;
     }[];
 }
-export interface ConcreteType {
+export interface ConcreteType extends McdocBaseType {
     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 {
+export interface MappedType extends McdocBaseType {
+    kind: 'mapped';
+    child: McdocType;
+    mapping: {
+        [path: string]: McdocType;
+    };
+}
+export declare const EmptyUnion: UnionType<never>;
+export declare function createEmptyUnion(attributes?: Attributes): UnionType<never>;
+export interface KeywordType extends McdocBaseType {
     kind: 'any' | 'boolean' | 'unsafe';
 }
-export interface StringType {
+export interface StringType extends McdocBaseType {
     kind: 'string';
     lengthRange?: NumericRange;
 }
-export type LiteralValue = {
+export type LiteralValue = LiteralBooleanValue | LiteralStringValue | LiteralNumericValue;
+export interface LiteralBooleanValue {
     kind: 'boolean';
     value: boolean;
-} | {
+}
+export interface LiteralStringValue {
     kind: 'string';
     value: string;
-} | {
-    kind: 'number';
+}
+export interface LiteralNumericValue {
+    kind: NumericTypeKind;
     value: number;
-    suffix: 'b' | 's' | 'l' | 'f' | 'd' | undefined;
-};
-export interface LiteralType {
+}
+export interface LiteralType extends McdocBaseType {
     kind: 'literal';
     value: LiteralValue;
 }
-export declare const LiteralNumberSuffixes: readonly ["b", "s", "l", "f", "d"];
-export type LiteralNumberSuffix = (typeof LiteralNumberSuffixes)[number];
-export declare const LiteralNumberCaseInsensitiveSuffixes: readonly ["b", "s", "l", "f", "d", "B", "S", "L", "F", "D"];
-export type LiteralNumberCaseInsensitiveSuffix = (typeof LiteralNumberCaseInsensitiveSuffixes)[number];
-export interface NumericType {
+export interface NumericType extends McdocBaseType {
     kind: NumericTypeKind;
     valueRange?: NumericRange;
 }
@@ -135,7 +155,7 @@ export declare const NumericTypeFloatKinds: readonly ["float", "double"];
 export type NumericTypeFloatKind = (typeof NumericTypeFloatKinds)[number];
 export declare const NumericTypeKinds: readonly ["byte", "short", "int", "long", "float", "double"];
 export type NumericTypeKind = (typeof NumericTypeKinds)[number];
-export interface PrimitiveArrayType {
+export interface PrimitiveArrayType extends McdocBaseType {
     kind: 'byte_array' | 'int_array' | 'long_array';
     valueRange?: NumericRange;
     lengthRange?: NumericRange;
@@ -144,63 +164,24 @@ export declare const PrimitiveArrayValueKinds: readonly ["byte", "int", "long"];
 export type PrimitiveArrayValueKind = (typeof PrimitiveArrayValueKinds)[number];
 export declare const PrimitiveArrayKinds: readonly ("byte_array" | "int_array" | "long_array")[];
 export type PrimitiveArrayKind = (typeof PrimitiveArrayKinds)[number];
-export interface ListType {
+export interface ListType extends McdocBaseType {
     kind: 'list';
     item: McdocType;
     lengthRange?: NumericRange;
 }
-export interface TupleType {
+export interface TupleType extends McdocBaseType {
     kind: 'tuple';
     items: McdocType[];
 }
-export type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType | AttributedType | IndexedType | TemplateType | ConcreteType;
+export interface McdocBaseType {
+    attributes?: Attributes;
+}
+export type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType | IndexedType | TemplateType | ConcreteType | MappedType;
 export declare namespace McdocType {
+    function equals(a: McdocType, b: McdocType): boolean;
     function toString(type: McdocType | undefined): string;
 }
-/**
- * A type that doesn't include a dispatcher type.
- */
-export type DispatchedType = Exclude<McdocType, DispatcherType | UnionType> | UnionType<DispatchedType>;
-/**
- * A type that doesn't include a reference type.
- */
-export type DereferencedType = Exclude<McdocType, ReferenceType | UnionType> | UnionType<DereferencedType>;
-/**
- * A type that doesn't include a dispatcher type or a reference type.
- */
-export type TangibleType = Exclude<McdocType, DispatcherType | ReferenceType | UnionType> | UnionType<TangibleType>;
-/**
- * A type that is {@link TangibleType} and doesn't have any indices.
- */
-export type ResolvedType = (Exclude<McdocType, DispatcherType | ReferenceType | UnionType> | UnionType<ResolvedType>) & NoIndices;
-type NoIndices = {
-    indices?: undefined;
-};
-export interface FlatStructType {
-    kind: 'flat_struct';
-    fields: Record<string, McdocType>;
-}
-export declare const flattenUnionType: (union: UnionType) => UnionType;
-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, }: {
-    source: McdocType | undefined;
-    target: McdocType | undefined;
-}) => {
-    isAssignable: boolean;
-    errorMessage?: string;
-};
-/**
- * https://spyglassmc.com/user/mcdoc/#p-RuntimeValue
- */
-export interface RuntimeValue {
-    asString(): string | undefined;
-    getKeyOnParent(): RuntimeValue | undefined;
-    getParent(): RuntimeValue | undefined;
-    getValue(key: string): RuntimeValue | undefined;
-}
-export declare function resolveType(inputType: McdocType, ctx: ProcessorContext, value: RuntimeValue | undefined): ResolvedType;
-export {};
+export interface UseStatementBindingData {
+    target: readonly string[];
+}
 //# sourceMappingURL=index.d.ts.map