@lcap/nasl-language-server-core 4.4.2-rc.5 → 4.5.0-beta.2

package/out/typer/component-def-manager/component-def-manager.d.ts

@@ -9,8 +9,20 @@ type NormalizedTag = string & {
 };
 export declare function isViewElementDefinition(def: SyntaxNode): def is ViewElementDefinition;
 export declare function isGeneralViewElementDefinition(def: SyntaxNode): def is GeneralViewElementDefinition;
+export declare class ComponentTagUtils {
+    /**
+     * 1. 将 kebab-case 转换为 PascalCase
+     * 2. 将 PascalCase 转换为 PascalCase
+     * 3. 将 camelCase 转换为 PascalCase
+     * @param tag
+     * @returns
+     */
+    static normalizeTag(tag: string): NormalizedTag;
+    static extractBusinessComponentQNameAsTag(nd: BusinessComponent): NormalizedTag;
+}
 export declare class ComponentDefManager {
     private gComponents;
+    private typeParamMetaCache;
     private defToTag;
     /**
      * 清空一切组件定义
@@ -60,6 +72,11 @@ export declare class ComponentDefManager {
      * @returns 属性标题，如果没有则返回属性名本身
      */
     getPropTitle(componentTag: string, propName: string): string;
+    /**
+     * 获取某个组件的 TypeParamMeta 映射（rawName → meta），带懒缓存。
+     * 不需要实例化 ViewElementDefinitionHelper，可安全在 checker 中使用。
+     */
+    getTypeParamMetaMap(componentTag: string): Map<string, TypeParamMeta> | undefined;
     private queryByNormalizedTag;
     /**
      * 根据ViewElement，查询组件的定义(若有多个返回最先注册的一个)
@@ -75,15 +92,36 @@ type RenamedTypeParamWrapper = {
     rawName: string;
     renamed: TypeAnnotation;
 };
+/**
+ * 类型变元在组件中的结构性角色，完全通过分析 d.ts 定义的类型结构自动识别，
+ * 不依赖类型参数名称（T/V/C/M/P 等）。
+ *
+ * - dataItem:    出现在 `{ list: List<X>, total: Integer } | List<X>` 模式中，代表行/列表项类型
+ * - valueResult: 是某个 `(item: DataItem) => X` 函数属性的返回类型，代表值字段类型
+ * - booleanFlag: 在 typeParams 声明中带有 `extends Boolean` 约束，代表布尔开关类型
+ */
+export type TypeParamRole = 'dataItem' | 'valueResult' | 'booleanFlag' | 'converterLiteral';
+/**
+ * 单个类型变元的兜底策略配置，完全由结构分析自动生成。
+ */
+export interface TypeParamMeta {
+    role: TypeParamRole;
+    /** 该类型参数是否拥有自己的数据源，用于区分"自有数据"和"从祖先继承" */
+    hasOwnDataSource: boolean;
+    /** 该类型参数对应的数据源属性名（若 hasOwnDataSource 为 true） */
+    dataSourcePropName?: string;
+    /** 当类型变元在完全求解后仍然 unresolved 时，统一到的默认类型 */
+    defaultWhenUnresolved?: TypeAnnotation;
+    /** 当某个初始化属性缺省/为空时，根据该属性的值推导出一个默认类型 */
+    defaultFromProp?: {
+        propName: string;
+        mode: 'booleanFlag' | 'converterLiteral' | 'stringLiteral';
+    };
+}
 declare class ViewElementDefinitionHelper {
-    /**
-     * 如有必要，重命名了类型变量后的组件定义
-     */
     private renamedDef;
-    /**
-     * 原始组件定义
-     */
     private rawDef;
+    private typeParamMetaMap;
     readonly implicitToStringPropsSet: ReadonlySet<string>;
     constructor(option: {
         def: ViewElementDefinition;
@@ -114,6 +152,12 @@ declare class ViewElementDefinitionHelper {
      * @returns
      */
     getInitPropsTypeAnnotation(): TypeAnnotation | undefined;
+    /**
+     * 根据 slotTarget 获取slot的scope类型
+     * @param slotTarget
+     * @returns
+     */
+    getSlotPropBySlotTarget(slotTarget: string): StructureProperty | undefined;
     /**
      * 根据 slotTarget 获取slot的参数类型
      * @param slotTarget
@@ -122,11 +166,25 @@ declare class ViewElementDefinitionHelper {
      * 1. 返回 非null，表示需要引入current
      * 2. 返回 null, 表示不需要引入current
      */
-    getSlotScopeTypeBySlotTarget(slotTarget: string): [{
+    getSlotScopeType(slotProp: StructureProperty): [{
         name: string;
         type: TypeAnnotation;
     }] | null;
     getRenamedTypeParamWrappers(): RenamedTypeParamWrapper[];
+    /**
+     * 获取某个原始类型参数名对应的兜底策略配置。
+     */
+    getTypeParamMeta(rawName: string): TypeParamMeta | undefined;
+    /**
+     * 基于原始组件定义的类型结构，自动识别每个 typeParam 的角色并生成兜底策略。
+     * 完全不依赖 typeParam 的名字（T/V/C/M/P 等），只依赖类型结构模式匹配。
+     */
+    private buildTypeParamMeta;
 }
+/**
+ * 基于原始组件定义的类型结构，自动识别每个 typeParam 的角色并生成兜底策略。
+ * 独立于 ViewElementDefinitionHelper 实例，可在不实例化的场景下使用（如 checker）。
+ */
+export declare function buildTypeParamMetaFromRawDef(rawDef: ViewElementDefinition): Map<string, TypeParamMeta>;
 export {};
 //# sourceMappingURL=component-def-manager.d.ts.map

package/out/typer/component-def-manager/component-def-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-def-manager.d.ts","sourceRoot":"","sources":["../../../src/typer/component-def-manager/component-def-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"component-def-manager.d.ts","sourceRoot":"","sources":["../../../src/typer/component-def-manager/component-def-manager.ts"],"names":[],"mappings":"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"}

package/out/typer/component-def-manager/component-def-manager.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComponentDefManager = exports.isGeneralViewElementDefinition = exports.isViewElementDefinition = void 0;
+exports.buildTypeParamMetaFromRawDef = exports.ComponentDefManager = exports.ComponentTagUtils = exports.isGeneralViewElementDefinition = exports.isViewElementDefinition = void 0;
 const type_manager_1 = require("../type-manager");
 const lodash_1 = require("lodash");
 const nasl_utils_1 = require("@lcap/nasl-utils");
@@ -15,11 +15,17 @@ function kebabToPascal(input) {
 }
 function isViewElementDefinition(def) {
     // FIXME: 处理一下这个函数
+    const ty = def;
     return (def.concept === 'TypeAnnotation' &&
         // 排除 nasl.ui.showMessage 这种函数
-        def.typeKind !== 'function' &&
+        ty.typeKind !== 'function' &&
+        // 类型别名（conditional / union 等）不是 View 组件；否则误入 compDefMgr，gQNameDefs 中缺失（如 DateConverterToType）
+        ty.typeKind !== 'conditional' &&
+        ty.typeKind !== 'union' &&
+        // 带泛参的 DTS：仅 props 为匿名结构的为 UI 组件；类型别名包装体 returnType 为 conditional 等，须归入 gQNameDefs
+        (ty.typeKind !== 'generic' || ty.returnType?.[0]?.typeKind === 'anonymousStructure') &&
         // 排除 组件的Options 类
-        !def.typeName?.endsWith('Options'));
+        !ty.typeName?.endsWith('Options'));
 }
 exports.isViewElementDefinition = isViewElementDefinition;
 function isGeneralViewElementDefinition(def) {
@@ -43,9 +49,11 @@ class ComponentTagUtils {
         return qName;
     }
 }
+exports.ComponentTagUtils = ComponentTagUtils;
 class ComponentDefManager {
     constructor() {
         this.gComponents = new Map();
+        this.typeParamMetaCache = new Map();
     }
     defToTag(def) {
         switch (def.concept) {
@@ -214,6 +222,22 @@ class ComponentDefManager {
         const group = this.gComponents.get(normalizedTag);
         return group?.propTitles?.get(propName) ?? propName;
     }
+    /**
+     * 获取某个组件的 TypeParamMeta 映射（rawName → meta），带懒缓存。
+     * 不需要实例化 ViewElementDefinitionHelper，可安全在 checker 中使用。
+     */
+    getTypeParamMetaMap(componentTag) {
+        const normalizedTag = ComponentTagUtils.normalizeTag(componentTag);
+        const cached = this.typeParamMetaCache.get(normalizedTag);
+        if (cached)
+            return cached;
+        const result = this.queryByNormalizedTag(normalizedTag);
+        if (!result)
+            return undefined;
+        const meta = buildTypeParamMetaFromRawDef(result.rawDef);
+        this.typeParamMetaCache.set(normalizedTag, meta);
+        return meta;
+    }
     queryByNormalizedTag(tag) {
         // 返回最先注册的一个。没有特殊的原因，返回最后一个注册的也可以。
         const rawDef = (0, lodash_1.head)(this.gComponents.get(tag)?.defs)?.def;
@@ -254,6 +278,219 @@ class NameTransformer {
         return name.replace(/^\S/, (s) => s.toUpperCase());
     }
 }
+// ─── 结构化类型参数角色识别工具 ──────────────────────────────────────
+// 以下函数通过分析 initProps 的类型结构（而非类型参数名字）来识别角色。
+/**
+ * 检查一个 TypeAnnotation 是否引用了指定的 typeParam（按 typeName 匹配）。
+ */
+function isTyRef(ty, paramName) {
+    return ty?.typeKind === 'typeParam' && ty.typeName === paramName;
+}
+/**
+ * 从匿名结构 `{ list: List<X>, ... }` 中提取 typeParam 名。
+ * 仅匹配包含 `list: List<X>` 属性的匿名结构——这是 dataSource 的标志性结构。
+ * 不匹配独立的 `List<X>`（如 `values: List<V>`），避免把 value 类型错误识别为 dataItem。
+ */
+function extractTypeParamFromStructuredList(ty, typeParamNames) {
+    if (!ty)
+        return undefined;
+    if (ty.typeKind === 'anonymousStructure' && ty.properties?.length) {
+        const listProp = ty.properties.find((p) => p.name === 'list');
+        if (listProp?.typeAnnotation?.typeName === 'List' &&
+            listProp.typeAnnotation.typeNamespace === 'nasl.collection' &&
+            listProp.typeAnnotation.typeArguments?.[0]?.typeKind === 'typeParam') {
+            const name = listProp.typeAnnotation.typeArguments[0].typeName;
+            if (name && typeParamNames.has(name))
+                return name;
+        }
+    }
+    return undefined;
+}
+/**
+ * 在一个可能是 union 的类型里搜索 dataSource 模式。
+ * 仅当类型中包含 `{ list: List<X>, ... }` 匿名结构时才认定为 dataSource 模式。
+ *
+ * 匹配以下结构:
+ * - `{ list: List<X>, total: Integer }`                        （直接结构）
+ * - `{ list: List<X>, total: Integer } | List<X>`              （union 包含结构）
+ * - `{ list: List<X>, total: Integer } | List<X> | OtherType`  （union 多分支）
+ *
+ * 不匹配:
+ * - `List<V>`        （独立 List，如 values: List<V>、pageSizeOptions: List<Integer>）
+ * - `List<V> | null`  （没有 { list: List<X> } 的 union）
+ */
+function extractDataItemFromType(ty, typeParamNames) {
+    if (!ty)
+        return undefined;
+    if (ty.typeKind === 'union' && ty.typeArguments?.length) {
+        for (const alt of ty.typeArguments) {
+            const found = extractTypeParamFromStructuredList(alt, typeParamNames);
+            if (found)
+                return found;
+        }
+    }
+    return extractTypeParamFromStructuredList(ty, typeParamNames);
+}
+/**
+ * 扫描所有 initProps，找出所有"数据项"类型参数。
+ * 返回 Map<typeParamName, dataSourcePropName>。
+ *
+ * 匹配两种数据源模式：
+ * 1. `{ list: List<T>, total: Integer }` 结构模式（如 UTableView）
+ * 2. `dataSource: List<T>` 直接 List 模式（如 USelectableSteps）
+ */
+function findDataItemTypeParams(props, typeParamNames) {
+    const result = new Map();
+    for (const prop of props) {
+        const found = extractDataItemFromType(prop.typeAnnotation, typeParamNames);
+        if (found && !result.has(found)) {
+            result.set(found, prop.name);
+            continue;
+        }
+        // 直接 List<T> 模式：dataSource: nasl.collection.List<T>
+        if (prop.name === 'dataSource') {
+            const ty = prop.typeAnnotation;
+            if (ty?.typeName === 'List' &&
+                ty.typeNamespace === 'nasl.collection' &&
+                ty.typeArguments?.[0]?.typeKind === 'typeParam') {
+                const paramName = ty.typeArguments[0].typeName;
+                if (paramName && typeParamNames.has(paramName) && !result.has(paramName)) {
+                    result.set(paramName, prop.name);
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 扫描所有 initProps，找出"值字段结果"类型参数。
+ * 匹配模式: 某个属性类型为 `(item: DataItem) => X`，其中 X 是一个 typeParam。
+ */
+function findValueResultTypeParams(props, typeParamNames, dataItemParamNames) {
+    const result = new Set();
+    for (const prop of props) {
+        const ty = prop.typeAnnotation;
+        if (ty?.typeKind !== 'function' || !ty.fnArgs?.length || !ty.returnType?.length)
+            continue;
+        const firstArgType = ty.fnArgs[0]?.type;
+        if (!firstArgType || firstArgType.typeKind !== 'typeParam')
+            continue;
+        if (!dataItemParamNames.has(firstArgType.typeName ?? ''))
+            continue;
+        const retTy = ty.returnType[0];
+        if (retTy?.typeKind === 'typeParam' && retTy.typeName && typeParamNames.has(retTy.typeName)) {
+            result.add(retTy.typeName);
+        }
+    }
+    return result;
+}
+/**
+ * 检测带有 `extends Boolean` 约束的类型参数。
+ * 在 rawDef.typeParams 上判断 constraints 字段。
+ */
+function findBooleanConstraintTypeParams(typeParams) {
+    const result = new Set();
+    for (const tp of typeParams) {
+        const name = tp.typeName;
+        if (!name)
+            continue;
+        // constraints 是单个 TypeAnnotation（多个约束时为 union 类型）
+        const constraint = tp.constraints;
+        if (!constraint)
+            continue;
+        const isBooleanConstraint = (c) => c.typeNamespace === 'nasl.core' && c.typeName === 'Boolean';
+        if (isBooleanConstraint(constraint)) {
+            result.add(name);
+        }
+        else if (constraint.typeKind === 'union' && constraint.typeArguments?.some(isBooleanConstraint)) {
+            result.add(name);
+        }
+    }
+    return result;
+}
+/**
+ * 为 booleanFlag 类型参数找到对应的属性名。
+ * 策略：在 initProps 中找到类型直接是该 typeParam 的属性（排除已被识别为 dataItem/valueResult 的）。
+ */
+function findBooleanPropForTypeParam(paramName, props, excludeParams) {
+    if (excludeParams.has(paramName))
+        return undefined;
+    for (const prop of props) {
+        if (isTyRef(prop.typeAnnotation, paramName)) {
+            return prop.name;
+        }
+    }
+    return undefined;
+}
+/** 类型参数约束为字面量 union（如 C extends 'auto' | 'string'），用于识别 converter / picker 的 type 等 */
+function hasStringLiteralUnionConstraint(tp) {
+    const c = tp.constraints;
+    if (!c)
+        return false;
+    const ok = (ty) => {
+        if (!ty)
+            return false;
+        if (ty.typeKind === 'literal')
+            return typeof ty.literal === 'string';
+        if (ty.typeKind === 'union' && ty.typeArguments?.length) {
+            return ty.typeArguments.every((a) => ok(a));
+        }
+        return false;
+    };
+    return ok(c);
+}
+/**
+ * 扫描属性类型中的条件类型，找出用作 checkType 的类型参数。
+ * 例如 `value: C extends '' ? List<V> : String` 中，C 是条件标志。
+ * 返回 Map<typeParamName, { extendsType, propName? }>。
+ */
+function findConditionalFlagTypeParams(props, typeParamNames, assignedParams) {
+    const result = new Map();
+    for (const prop of props) {
+        const ty = prop.typeAnnotation;
+        if (ty?.typeKind !== 'conditional')
+            continue;
+        const checkType = ty.checkType;
+        if (checkType?.typeKind === 'typeParam' &&
+            checkType.typeName &&
+            typeParamNames.has(checkType.typeName) &&
+            !assignedParams.has(checkType.typeName) &&
+            ty.extendsType) {
+            result.set(checkType.typeName, { extendsType: ty.extendsType, propName: undefined });
+        }
+    }
+    for (const [paramName, info] of result) {
+        const lit = info.extendsType;
+        if (lit.typeKind === 'literal') {
+            for (const prop of props) {
+                const pty = prop.typeAnnotation;
+                if (!pty)
+                    continue;
+                if (pty.typeKind === 'union' &&
+                    pty.typeArguments?.some((a) => a.typeKind === 'literal' && a.literal === lit.literal)) {
+                    info.propName = prop.name;
+                    break;
+                }
+                if (pty.typeKind === 'literal' && pty.literal === lit.literal) {
+                    info.propName = prop.name;
+                    break;
+                }
+            }
+        }
+        // modelValue 等：外层条件是 DT extends 'date'，但 init 里是 type: DT（类型参数），
+        // 不是字面量 union，上面匹配不到；用「属性类型即该类型参数」补上（如 el-date-picker）。
+        if (!info.propName) {
+            for (const prop of props) {
+                if (isTyRef(prop.typeAnnotation, paramName)) {
+                    info.propName = prop.name;
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+}
+// ─── ViewElementDefinitionHelper ──────────────────────────────────
 class ViewElementDefinitionHelper {
     constructor(option, env) {
         this.rawDef = option.def;
@@ -267,6 +504,7 @@ class ViewElementDefinitionHelper {
             env.unifier.inPlaceRenameTy(defWithTypeParams);
         }
         this.renamedDef = defWithTypeParams;
+        this.typeParamMetaMap = this.buildTypeParamMeta();
     }
     /**
      * 为组件定义增加 _if: boolean 属性
@@ -358,6 +596,15 @@ class ViewElementDefinitionHelper {
     getInitPropsTypeAnnotation() {
         return this.renamedDef.typeArguments?.[0];
     }
+    /**
+     * 根据 slotTarget 获取slot的scope类型
+     * @param slotTarget
+     * @returns
+     */
+    getSlotPropBySlotTarget(slotTarget) {
+        const slotMethodName = `slot${NameTransformer.toFirstUpper(NameTransformer.toHump(slotTarget))}`;
+        return this.getInitPropsTypeAnnotation()?.properties?.find((prop) => prop.name === slotMethodName);
+    }
     /**
      * 根据 slotTarget 获取slot的参数类型
      * @param slotTarget
@@ -366,14 +613,11 @@ class ViewElementDefinitionHelper {
      * 1. 返回 非null，表示需要引入current
      * 2. 返回 null, 表示不需要引入current
      */
-    getSlotScopeTypeBySlotTarget(slotTarget) {
-        const slotMethodName = `slot${NameTransformer.toFirstUpper(NameTransformer.toHump(slotTarget))}`;
-        const slotProp = this.getInitPropsTypeAnnotation()?.properties?.find((prop) => prop.name === slotMethodName);
+    getSlotScopeType(slotProp) {
         if (slotProp?.typeAnnotation?.typeKind === 'function' &&
             slotProp.typeAnnotation.fnArgs?.length) {
-            // 如果slotProp.typeAnnotation.fnArgs[0]?.name !== 'current'，那么报错提示一下用户
             if (slotProp.typeAnnotation.fnArgs[0]?.name !== 'current') {
-                console.error(`[getSlotParamTypeBySlotTarget] slotTarget: ${slotTarget}, 目前只支持current作为slot变量的名字，请使用current作为slot变量的名字`);
+                console.error(`[getSlotScopeType] slotProp: ${slotProp.name}, 目前只支持current作为slot变量的名字，请使用current作为slot变量的名字`);
             }
             return [
                 {
@@ -392,5 +636,153 @@ class ViewElementDefinitionHelper {
             return { rawName, renamed: x };
         }) ?? []);
     }
+    /**
+     * 获取某个原始类型参数名对应的兜底策略配置。
+     */
+    getTypeParamMeta(rawName) {
+        return this.typeParamMetaMap.get(rawName);
+    }
+    /**
+     * 基于原始组件定义的类型结构，自动识别每个 typeParam 的角色并生成兜底策略。
+     * 完全不依赖 typeParam 的名字（T/V/C/M/P 等），只依赖类型结构模式匹配。
+     */
+    buildTypeParamMeta() {
+        return buildTypeParamMetaFromRawDef(this.rawDef);
+    }
+}
+/**
+ * 基于原始组件定义的类型结构，自动识别每个 typeParam 的角色并生成兜底策略。
+ * 独立于 ViewElementDefinitionHelper 实例，可在不实例化的场景下使用（如 checker）。
+ */
+function buildTypeParamMetaFromRawDef(rawDef) {
+    const map = new Map();
+    const rawTypeParams = rawDef.typeParams ?? [];
+    if (!rawTypeParams.length)
+        return map;
+    const rawInitProps = rawDef.typeArguments?.[0]?.properties ?? [];
+    const typeParamNames = new Set(rawTypeParams.map((tp) => tp.typeName).filter((n) => !!n));
+    const dataItemMap = findDataItemTypeParams(rawInitProps, typeParamNames);
+    const dataItemNames = new Set(dataItemMap.keys());
+    const valueResultNames = findValueResultTypeParams(rawInitProps, typeParamNames, dataItemNames);
+    const booleanNames = findBooleanConstraintTypeParams(rawTypeParams);
+    const assignedParams = new Set([...dataItemNames, ...valueResultNames]);
+    const conditionalFlagExcludes = new Set([...assignedParams, ...booleanNames]);
+    const conditionalFlags = findConditionalFlagTypeParams(rawInitProps, typeParamNames, conditionalFlagExcludes);
+    rawTypeParams.forEach((tp) => {
+        const name = tp.typeName;
+        if (!name)
+            return;
+        if (dataItemNames.has(name)) {
+            map.set(name, {
+                role: 'dataItem',
+                hasOwnDataSource: true,
+                dataSourcePropName: dataItemMap.get(name),
+                defaultWhenUnresolved: type_manager_1.naslStringTy,
+            });
+        }
+        else if (valueResultNames.has(name)) {
+            map.set(name, {
+                role: 'valueResult',
+                hasOwnDataSource: false,
+                defaultWhenUnresolved: type_manager_1.naslStringTy,
+            });
+        }
+        else if (booleanNames.has(name)) {
+            const propName = findBooleanPropForTypeParam(name, rawInitProps, assignedParams);
+            map.set(name, {
+                role: 'booleanFlag',
+                hasOwnDataSource: false,
+                defaultFromProp: propName ? { propName, mode: 'booleanFlag' } : undefined,
+                // 当无法通过结构匹配找到对应的 Boolean 属性时（如 van-pickerson 的 M 对应 multiple，
+                // 但 multiple 类型是 Boolean 而非 M），提供 false 作为兜底默认值，
+                // 确保条件类型（如 M extends true ? List<V> : V）能够正确解出。
+                defaultWhenUnresolved: propName ? undefined : nasl_concepts_1.TypeAnnotation.createLiteral(false),
+            });
+        }
+        else if (conditionalFlags.has(name)) {
+            const flagInfo = conditionalFlags.get(name);
+            const constraint = tp.constraints;
+            map.set(name, {
+                role: 'converterLiteral',
+                hasOwnDataSource: false,
+                defaultFromProp: flagInfo.propName
+                    ? { propName: flagInfo.propName, mode: 'converterLiteral' }
+                    : undefined,
+                // 有对应 init 属性（如 type: DT）时，缺省应用整个字面量约束 union，而不是仅 extends 分支上的字面量（如 'date'）
+                defaultWhenUnresolved: flagInfo.propName && constraint ? constraint : flagInfo.extendsType,
+            });
+        }
+    });
+    rawTypeParams.forEach((tp) => {
+        const name = tp.typeName;
+        if (!name || map.has(name))
+            return;
+        const usedInFieldOrSlot = rawInitProps.some((prop) => {
+            const ty = prop.typeAnnotation;
+            if (!ty || ty.typeKind !== 'function' || !ty.fnArgs?.length)
+                return false;
+            const firstArgName = ty.fnArgs[0]?.name;
+            if (firstArgName !== 'item' && firstArgName !== 'current')
+                return false;
+            if (isTyRef(ty.fnArgs[0]?.type, name))
+                return true;
+            const argTy = ty.fnArgs[0]?.type;
+            if (argTy?.typeArguments?.some((a) => isTyRef(a, name)))
+                return true;
+            return false;
+        });
+        if (usedInFieldOrSlot) {
+            map.set(name, {
+                role: 'dataItem',
+                hasOwnDataSource: false,
+                defaultWhenUnresolved: type_manager_1.naslStringTy,
+            });
+        }
+    });
+    rawTypeParams.forEach((tp) => {
+        const name = tp.typeName;
+        if (!name || map.has(name))
+            return;
+        const usedInSlotCurrentStruct = rawInitProps.some((prop) => {
+            const ty = prop.typeAnnotation;
+            if (!ty || ty.typeKind !== 'function' || !ty.fnArgs?.length)
+                return false;
+            const firstArgName = ty.fnArgs[0]?.name;
+            if (firstArgName !== 'item' && firstArgName !== 'current')
+                return false;
+            const argTy = ty.fnArgs[0]?.type;
+            if (argTy?.typeKind === 'anonymousStructure') {
+                return argTy.properties?.some((p) => isTyRef(p.typeAnnotation, name)) ?? false;
+            }
+            return false;
+        });
+        if (usedInSlotCurrentStruct) {
+            map.set(name, {
+                role: 'valueResult',
+                hasOwnDataSource: false,
+                defaultWhenUnresolved: type_manager_1.naslStringTy,
+            });
+        }
+    });
+    // converter: C 等：未出现在顶层 conditional 的 checkType 上，但 init 上有「属性类型即该类型参数」
+    rawTypeParams.forEach((tp) => {
+        const name = tp.typeName;
+        if (!name || map.has(name))
+            return;
+        if (!hasStringLiteralUnionConstraint(tp))
+            return;
+        const directProp = rawInitProps.find((p) => isTyRef(p.typeAnnotation, name));
+        if (!directProp)
+            return;
+        const constraint = tp.constraints;
+        map.set(name, {
+            role: 'converterLiteral',
+            hasOwnDataSource: false,
+            defaultFromProp: { propName: directProp.name, mode: 'converterLiteral' },
+            defaultWhenUnresolved: constraint ?? type_manager_1.naslStringTy,
+        });
+    });
+    return map;
 }
+exports.buildTypeParamMetaFromRawDef = buildTypeParamMetaFromRawDef;
 //# sourceMappingURL=component-def-manager.js.map