@miot-rn/common-component 1.0.1

package/dist/specs/instance-parser.js

@@ -0,0 +1,706 @@
+/* eslint-disable no-use-before-define, @typescript-eslint/no-use-before-define, @typescript-eslint/no-explicit-any */
+import { isSpecProp } from "../utils/spec";
+import { safeTrim } from "../utils/fns";
+let CachedInstance = null;
+let CachedIidsGetter = null;
+let CachedSpecVersion = null;
+const QuerySpecsCache = {};
+// 初始化，记录instance, 方便后续直接使用
+export function init(instance) {
+  if (instance) {
+    setCachedInstance(instance);
+    setCachedSpecVersion(instance);
+    setCachedIidsGetter(instance);
+  }
+}
+function setCachedInstance(instance) {
+  CachedInstance = instance;
+}
+export function getInstance() {
+  return CachedInstance;
+}
+
+/**
+ * 设置缓存的规格版本
+ * @param {Object} instance - 设备实例对象
+ */
+function setCachedSpecVersion(instance) {
+  // 根据protocol-version字段获取版本，如果不存在则根据modules数组判断
+  if (instance?.['protocol-version']) {
+    // 将protocol-version字符串转为整数类型，如"3.0"转为3
+    const versionStr = instance['protocol-version'].split('.')[0];
+    CachedSpecVersion = parseInt(versionStr, 10) || 2;
+  } else {
+    // 如果没有protocol-version字段，则为specV2版本
+    CachedSpecVersion = 2;
+  }
+}
+
+/**
+ * 获取当前缓存的规格版本
+ * @returns {number} - 规格版本号
+ */
+export function getSpecVersion() {
+  return CachedSpecVersion;
+}
+
+/**
+ * 获取动态类型
+ * @returns {number} - 动态类型值，如果不存在则默认为0
+ */
+export function getDynamicType() {
+  // 从instance中直接获取dynamic字段，如果不存在则默认为0
+  return CachedInstance?.dynamic !== undefined ? Number(CachedInstance.dynamic) : 0;
+}
+
+/**
+ * 获取有效的模块列表
+ * @returns {Array} - 返回有效的模块数组
+ */
+export function getValidModules() {
+  const specVersion = getSpecVersion();
+  // 如果是版本2，返回包含整个实例的数组
+  // 如果是版本3，返回所有模块，但排除名为'basic'的模块
+  return specVersion < 3 ? [CachedInstance] : CachedInstance?.modules || [];
+}
+function setCachedIidsGetter(_instance) {
+  CachedIidsGetter = getIidsGetter();
+}
+export function parseSpecType(type) {
+  return CachedSpecVersion === 3 ? parseSpecType3(type) : parseSpecType2(type);
+}
+function parseSpecType2(type) {
+  const splited = (type || '').split(':');
+  return {
+    key: splited[3],
+    version: parseInt(splited[6], 10)
+  };
+}
+function parseSpecType3(type) {
+  const [std] = (type || '').split(';');
+  const splitStd = (std || '').split(':');
+  return {
+    key: splitStd[4],
+    version: parseInt(splitStd[6], 10) || 0
+  };
+}
+
+/**
+ * 创建规格查询函数
+ * @returns {Function} - 返回规格查询函数
+ */
+function getIidsGetter() {
+  /**
+   * 根据查询参数获取规格信息
+   * @param {QuerySpecParams} params - 查询参数
+   * @returns {Array} - 返回匹配的规格数组
+   */
+  return function querySpecs(params = {}) {
+    // 解构参数
+    const {
+      mkey,
+      mDescription,
+      skey,
+      sDescription,
+      pkey,
+      akey,
+      ekey,
+      description,
+      dataSource
+    } = params;
+
+    // 预处理描述类字段，规避人为空格导致的错配
+    const normalizedMKey = safeTrim(mkey);
+    const normalizedMDescription = safeTrim(mDescription);
+    const normalizedSDescription = safeTrim(sDescription);
+    const normalizedDescription = safeTrim(description);
+    // console.log('querySpecs-----params', params);
+    // console.log('querySpecs-----CachedInstance', CachedInstance);
+    // console.log('querySpecs-----protocol-version', CachedInstance?.['protocol-version'], CachedSpecVersion);
+
+    // 基本参数验证
+    if (!skey || !pkey && !akey && !ekey) {
+      return [];
+    }
+
+    // 生成缓存键
+    const cacheKey = `${ekey ? 'event' : akey ? 'action' : 'prop'}:${normalizedMDescription || '-'}:${normalizedMKey || '-'}:${normalizedSDescription || '-'}:${skey}:${normalizedDescription || '-'}:${ekey || akey || pkey}`;
+
+    // 检查缓存
+    if (cacheKey in QuerySpecsCache) {
+      return QuerySpecsCache[cacheKey];
+    }
+
+    // 获取目标模块
+    const targetModule = findModuleByKeyAndDescription(normalizedMKey, normalizedMDescription);
+    // console.log('targetModule---', targetModule);
+
+    if (!targetModule && mkey) {
+      return [];
+    }
+
+    // 查找匹配的服务
+    const services = (targetModule?.services || []).filter(service => {
+      return parseSpecType(service.type).key === skey && (!normalizedSDescription || normalizedSDescription === safeTrim(service.description));
+    }).reverse();
+    if (!services.length) {
+      return [];
+    }
+
+    // 存储结果的数组
+    const result = [];
+
+    // 处理服务版本控制
+    // 按描述分组，每个描述组内独立进行版本控制
+    const serviceGroups = {};
+
+    // 将服务按描述分组
+    for (const service of services) {
+      const serviceDescription = safeTrim(service.description) || '';
+      const serviceVersion = parseSpecType(service.type).version;
+      if (!serviceGroups[serviceDescription]) {
+        serviceGroups[serviceDescription] = serviceVersion;
+      }
+      // console.log('serviceVersion--', serviceVersion);
+      // console.log('serviceGroups[serviceDescription]--', serviceGroups[serviceDescription]);
+
+      // 版本控制，只处理最新版本
+      if (serviceVersion < serviceGroups[serviceDescription]) {
+        break;
+      }
+      // 获取属性/动作/事件列表
+      const propertyType = ekey ? 'events' : akey ? 'actions' : 'properties';
+      // console.log('propertyType--', propertyType);
+      const items = service[propertyType] || [];
+
+      // 查找匹配的属性/动作/事件
+      const matchedItems = items.filter(item => {
+        return parseSpecType(item.type).key === (ekey || akey || pkey) && (!normalizedDescription || normalizedDescription === safeTrim(item.description));
+      }).reverse();
+      // 按描述分组，每个描述组内独立进行版本控制
+      const itemGroups = {};
+
+      // 将属性/动作/事件按描述分组
+      for (const item of matchedItems) {
+        const itemDescription = safeTrim(item.description) || '';
+        const itemVersion = parseSpecType(item.type).version;
+        if (!itemGroups[itemDescription]) {
+          itemGroups[itemDescription] = itemVersion;
+        }
+        // 版本控制，只处理最新版本
+        if (itemVersion < itemGroups[itemDescription]) {
+          break;
+        }
+        // 处理过滤后的属性/动作/事件
+        // 构建规格对象
+        const spec = {
+          siid: service.iid,
+          [ekey ? 'eiid' : akey ? 'aiid' : 'piid']: item.iid,
+          skey,
+          [ekey ? 'ekey' : akey ? 'akey' : 'pkey']: ekey || akey || pkey,
+          service,
+          [ekey ? 'event' : akey ? 'action' : 'prop']: item,
+          dataSource,
+          source: item.source,
+          sDescription: serviceDescription
+        };
+
+        // 添加特定类型的属性
+        if (ekey) {
+          spec.arguments = item.arguments || [];
+        } else if (akey) {
+          spec.in = item.in || [];
+          spec.out = item.out || [];
+        } else if (pkey) {
+          // 处理属性相关事件
+          const events = service.events || [];
+          const relatedEvents = events.filter(event => {
+            return event && event.arguments && event.arguments.includes(item.iid);
+          });
+          if (relatedEvents.length) {
+            spec.reiids = relatedEvents.map(event => event.iid);
+            spec.reIndexs = relatedEvents.map(event => event.arguments.findIndex(iid => iid === item.iid));
+          }
+        }
+
+        // 添加模块信息
+        if (mkey && targetModule) {
+          spec.miid = targetModule?.iid;
+          spec.mkey = mkey || parseSpecType(targetModule?.type).key;
+          spec.mDescription = normalizedMDescription;
+        }
+
+        // 将最新版本的结果添加到数组开头
+        result.unshift(spec);
+      }
+    }
+
+    // 缓存结果
+    QuerySpecsCache[cacheKey] = result;
+    return result;
+  };
+}
+
+/**
+ * 根据查询参数数组获取对应的规格信息
+ * @param {Array<QuerySpecParams>} keys - 查询参数数组，每个元素包含 {skey, pkey}, {skey, akey}, {skey, ekey} 等
+ * @returns {Array<Array<Object>>} - 返回二维数组，每个子数组包含匹配的规格信息 [{skey, pkey, siid, piid, service, prop}]
+ */
+export function getSpecs(keys) {
+  // 参数验证
+  if (!Array.isArray(keys)) {
+    return [];
+  }
+
+  // 使用缓存查询函数处理每个查询参数
+  return keys.map(queryParams => {
+    // 支持模块和描述等特殊逻辑
+    return CachedIidsGetter(queryParams);
+  });
+}
+
+/**
+ * 根据查询参数数组获取对应的规格信息中的第一项
+ * @param {Array<QuerySpecParams>} keys - 查询参数数组，每个元素包含 {skey, pkey}, {skey, akey}, {skey, ekey} 等
+ * @returns {Array<Object|null>} - 返回一维数组，每个元素是匹配的规格信息中的第一项或null [{skey, pkey, siid, piid, service, prop}]
+ */
+export function getSpecsOnly(keys) {
+  // 参数验证
+  if (!Array.isArray(keys)) {
+    return [];
+  }
+
+  // 使用缓存查询函数处理每个查询参数，并只取每个结果的第一项
+  return keys.map(queryParams => {
+    const specs = CachedIidsGetter(queryParams);
+    return specs && specs.length > 0 ? specs[0] : null;
+  });
+}
+
+/**
+ * 根据单个查询参数获取对应的规格信息中的第一项
+ * @param {QuerySpecParams} key - 查询参数，包含 {skey, pkey}, {skey, akey}, {skey, ekey} 等
+ * @returns {Object|null} - 返回匹配的规格信息中的第一项或null {skey, pkey, siid, piid, service, prop}
+ */
+export function getSpecOnly(key) {
+  const result = getSpecsOnly([key]);
+  return result.length > 0 ? result[0] : null;
+}
+
+/**
+ * 根据传入的属性（包括spec属性和虚拟属性），获取其IID信息
+ * @param {Array<Object>} specs - 规格数组，每个元素包含 {skey, pkey, siid, piid, prop, service, ...}
+ * @returns {Array<Object>} - 返回包含IID信息的数组 [{siid, piid, access, format, ...}]
+ */
+export function getSpecsIidsOnly(specs) {
+  // 参数验证
+  if (!Array.isArray(specs)) {
+    return [];
+  }
+
+  // 处理每个规格对象
+  return specs.map(spec => {
+    // 如果是虚拟属性，直接原样返回
+    if (!isSpecProp(spec)) {
+      return spec ? {
+        ...spec
+      } : spec;
+    }
+
+    // 提取属性类型ID（piid/aiid/eiid）
+    const propertyIdKey = 'eiid' in spec ? 'eiid' : 'aiid' in spec ? 'aiid' : 'piid';
+    const propertyIdValue = 'eiid' in spec ? spec.eiid : 'aiid' in spec ? spec.aiid : spec.piid;
+
+    // 构建IID信息对象
+    return {
+      access: spec.prop ? spec.prop.access : [],
+      'gatt-access': spec.prop ? spec.prop['gatt-access'] : [],
+      format: spec.prop ? spec.prop.format : '',
+      miid: spec.miid,
+      siid: spec.siid,
+      [propertyIdKey]: propertyIdValue,
+      in: spec.in || [],
+      reiids: spec.reiids || [],
+      reIndexs: spec.reIndexs || [],
+      dataSource: spec.dataSource,
+      source: spec.source
+    };
+  });
+}
+
+/**
+ * 查找 spec value-list 中 targetValue 对应的 index
+ * 如果找不到匹配的值，则返回-1。
+ *
+ * @param {object} spec - 包含规范的对象。
+ * @param {any} targetValue - 要查找的目标值。
+ * @returns {number} - 如果找到匹配的值，返回该值在'value-list'中的索引；否则返回-1。
+ */
+export function getIndexBySpecValue(spec, targetValue) {
+  const valueList = (spec?.prop?.['value-list'] || []).filter(item => item && item.value !== undefined);
+  const index = valueList.findIndex(item => item.value === targetValue);
+  return index;
+}
+
+/**
+ * 获取 value-list
+ * 如果不存在，返回 []。
+ *
+ * @param {object} spec - 包含规范的对象。
+ * @returns {Array} - 如果找到匹配的值，返回在'value-list'的值。
+ */
+export function getSpecValueList(spec) {
+  // @ts-ignore
+  return (spec?.prop?.['value-list'] || []).filter(item => item && item.value !== undefined);
+}
+
+/**
+ * 获取spec value-list 中对应description 的value
+ * @param {object} spec 目标属性
+ * @param {string} description 目标description
+ * @return {any} value 通常是number
+ */
+export function getValueBySpecDescription(spec, description) {
+  // @ts-ignore
+  const vl = spec && spec.prop && spec.prop['value-list'] ? spec.prop['value-list'] : [];
+  const normalizedDescription = safeTrim(description);
+  const value = (vl || []).find(v => {
+    const vDesc = safeTrim(v?.description) || '';
+    return v && vDesc.toLowerCase() === (normalizedDescription || '').toLowerCase();
+  });
+  return value ? value.value : undefined;
+}
+
+/**
+ * 获取 value-range
+ * 如果不存在，返回 []。
+ *
+ * @param {object} spec - 包含规范的对象。
+ * @returns {Array} - 如果找到匹配的值，返回在'value-range'的值。
+ */
+export function getSpecValueRange(spec) {
+  // @ts-ignore
+  return spec?.prop?.['value-range'] || [];
+}
+
+/**
+ * 获取spec value-list 中对应description 的index
+ * @param {object} spec 目标属性
+ * @param {string} description 目标description
+ * @return {any} value 通常是number
+ */
+export function getIndexBySpecDescription(spec, description) {
+  // @ts-ignore
+  const vl = spec && spec.prop && spec.prop['value-list'] ? spec.prop['value-list'] : [];
+  const normalizedDescription = safeTrim(description);
+  let ans = -1;
+  (vl || []).forEach((v, index) => {
+    const vDesc = safeTrim(v?.description) || '';
+    if (v && vDesc.toLowerCase() === (normalizedDescription || '').toLowerCase()) {
+      ans = index;
+    }
+  });
+  return ans;
+}
+
+/**
+ * 获取spec value-list 中对应description 的value，主要作用是兼容不规范的description
+ * 注意有优先级，先取前面的，取不到再取后面的
+ * @param {object} spec 目标属性
+ * @param {string} descriptions 目标descriptions, 从多个descriptions 中匹配出一个即可
+ * @return {any} value 通常是number
+ */
+export function getValueBySpecDescriptions(spec, descriptions = []) {
+  for (let i = 0, l = descriptions.length; i < l; i++) {
+    const v = getValueBySpecDescription(spec, safeTrim(descriptions[i]));
+    if (![undefined, null].includes(v)) {
+      return v;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * 获取value-list 中idle/none 状态的索引
+ * @param {object} spec 目标属性
+ * @return {number} index
+ */
+export function getIdleIndex(spec) {
+  // @ts-ignore
+  if (!spec || !spec.prop || !spec.prop['value-list']) {
+    return -1;
+  }
+  // @ts-ignore
+  return spec.prop['value-list'].findIndex(({
+    description
+  }) => {
+    return ['Idle', 'None'].includes(description);
+  });
+}
+
+/**
+ * 获取 instance 中的属性索引
+ * @param {object} instance
+ * @param {skey, pkey} search
+ * @returns
+ */
+export function getKeyIndexOfInstance(instance, search) {
+  const serviceIndex = (instance?.services || []).findIndex(item => {
+    return parseSpecType(item?.type).key === search.skey;
+  });
+  const propertyIndex = ((instance?.services?.[serviceIndex] || {}).properties || []).findIndex(item => {
+    return parseSpecType(item?.type).key === search.pkey;
+  });
+  return [serviceIndex, propertyIndex];
+}
+
+/**
+ * 根据IID信息确定要查找的属性类型
+ * @param {Object} iidInfo - 包含 piid, aiid, eiid 的对象
+ * @returns {string} - 返回 'properties', 'actions', 'events' 或 'unknown'
+ */
+function determinePropertyType({
+  piid,
+  aiid,
+  eiid
+}) {
+  if (piid) return 'properties';
+  if (aiid) return 'actions';
+  if (eiid) return 'events';
+  return 'unknown';
+}
+
+/**
+ * 根据IID信息确定属性ID的键名
+ * @param {Object} iidInfo - 包含 piid, aiid, eiid 的对象
+ * @returns {string} - 返回 'piid', 'aiid' 或 'eiid'
+ */
+function determinePropertyIdKey({
+  piid,
+  aiid,
+  eiid
+}) {
+  if (piid) return 'piid';
+  if (aiid) return 'aiid';
+  if (eiid) return 'eiid';
+  return 'unknown';
+}
+
+/**
+ * 根据IID信息确定spec键名
+ * @param {Object} iidInfo - 包含 piid, aiid, eiid 的对象
+ * @returns {string} - 返回 'pkey', 'akey' 或 'ekey'
+ */
+function determineSpecKey({
+  piid,
+  aiid,
+  eiid
+}) {
+  if (piid) return 'pkey';
+  if (aiid) return 'akey';
+  if (eiid) return 'ekey';
+  return 'unknown';
+}
+
+/**
+ * 根据IID信息确定spec属性名
+ * @param {Object} iidInfo - 包含 piid, aiid, eiid 的对象
+ * @returns {string} - 返回 'prop', 'action' 或 'event'
+ */
+function determineSpecProperty({
+  piid,
+  aiid,
+  eiid
+}) {
+  if (piid) return 'prop';
+  if (aiid) return 'action';
+  if (eiid) return 'event';
+  return 'unknown';
+}
+
+/**
+ * 验证IID信息是否有效
+ * @param {Object} iidInfo - 包含 siid, piid, aiid, eiid, miid 的对象
+ * @returns {boolean} - 如果有效返回true，否则返回false
+ */
+function isValidIidInfo(iidInfo) {
+  if (!iidInfo) return false;
+  const {
+    siid,
+    piid,
+    aiid,
+    eiid,
+    miid
+  } = iidInfo;
+
+  // 规格版本3需要提供miid
+  if (CachedSpecVersion === 3 && !miid) {
+    return false;
+  }
+  return siid && (piid || aiid || eiid);
+}
+
+/**
+ * 获取目标模块
+ * @param {number} miid - 模块ID
+ * @returns {Object|null} - 返回目标模块对象或null
+ */
+function getTargetModule(miid) {
+  // 如果是版本3，根据miid查找对应模块
+  if (CachedSpecVersion === 3) {
+    return (CachedInstance.modules || []).find(module => {
+      return module?.iid === miid;
+    });
+  }
+  // 如果是版本2，直接返回整个实例
+  return CachedInstance;
+}
+
+/**
+ * 根据mkey和mDescription查找模块
+ * @param {string} mkey - 模块键
+ * @param {string} mDescription - 模块描述（可选）
+ * @returns {Object|null} - 返回目标模块对象或null
+ */
+function findModuleByKeyAndDescription(mkey, mDescription) {
+  const normalizedMKey = safeTrim(mkey);
+  const normalizedMDescription = safeTrim(mDescription);
+  // 如果是版本3
+  if (CachedSpecVersion === 3) {
+    return (CachedInstance.modules || []).find(module => {
+      const moduleDescription = safeTrim(module?.description);
+      const moduleName = safeTrim(module?.name);
+      // 如果提供了mDescription，同时匹配mkey和mDescription
+      if (normalizedMDescription) {
+        return moduleName === normalizedMKey && moduleDescription === normalizedMDescription;
+      }
+      // 只匹配mkey
+      return moduleName === normalizedMKey;
+    });
+  }
+  // 如果是版本2，返回整个实例
+  return CachedInstance;
+}
+
+/**
+ * 获取目标服务
+ * @param {Object} module - 模块对象
+ * @param {number} siid - 服务ID
+ * @returns {Object} - 返回目标服务对象
+ */
+function getTargetService(module, siid) {
+  return (module?.services || []).find(service => {
+    return service?.iid === siid;
+  });
+}
+
+/**
+ * 获取目标属性/动作/事件
+ * @param {Object} service - 服务对象
+ * @param {Object} iidInfo - 包含 piid, aiid, eiid 的对象
+ * @returns {Object} - 返回目标属性/动作/事件对象
+ */
+function getTargetProperty(service, iidInfo) {
+  const propertyType = determinePropertyType(iidInfo);
+  if (propertyType === 'unknown') return null;
+  const {
+    piid,
+    aiid
+  } = iidInfo;
+  const propertyId = iidInfo[piid ? 'piid' : aiid ? 'aiid' : 'eiid'];
+  const properties = service[propertyType] || [];
+  return properties.find(pae => {
+    return pae?.iid === propertyId;
+  });
+}
+
+/**
+ * 构建规范对象
+ * @param {Object} iidInfo - IID信息
+ * @param {Object} service - 服务对象
+ * @param {Object} property - 属性/动作/事件对象
+ * @param {Object} module - 模块对象
+ * @returns {Object} - 返回构建的规范对象
+ */
+function buildSpecObject(iidInfo, service, property, module) {
+  const {
+    siid,
+    miid
+  } = iidInfo;
+  const propertyIdKey = determinePropertyIdKey(iidInfo);
+  const specKey = determineSpecKey(iidInfo);
+  const specProperty = determineSpecProperty(iidInfo);
+  const spec = {
+    siid,
+    [propertyIdKey]: property.iid,
+    skey: parseSpecType(service.type)?.key,
+    [specKey]: parseSpecType(property.type)?.key,
+    service,
+    [specProperty]: property,
+    source: property.source
+  };
+
+  // 如果是规格版本3，添加模块相关信息
+  if (CachedSpecVersion === 3) {
+    spec.miid = miid;
+    spec.mkey = parseSpecType(module.type)?.key;
+  }
+  return spec;
+}
+
+/**
+ * 根据IID获取规范信息
+ * @param {Object} iidInfo - 包含 {miid, siid, piid, aiid, eiid} 的对象
+ * @returns {Object|null} - 返回规范对象或null
+ */
+function getSpecByIid(iidInfo) {
+  // 验证IID信息是否有效
+  if (!isValidIidInfo(iidInfo)) {
+    return null;
+  }
+  const {
+    miid,
+    siid
+  } = iidInfo;
+
+  // 验证miid是否提供（规格版本3需要）
+  if (CachedSpecVersion === 3 && !miid) {
+    return null;
+  }
+
+  // 获取目标模块
+  const targetModule = getTargetModule(miid);
+  if (!targetModule) {
+    return null;
+  }
+
+  // 获取目标服务
+  const targetService = getTargetService(targetModule, siid);
+  if (!targetService) {
+    return null;
+  }
+
+  // 获取目标属性/动作/事件
+  const targetProperty = getTargetProperty(targetService, iidInfo);
+  if (!targetProperty) {
+    return null;
+  }
+
+  // 构建并返回规范对象
+  return buildSpecObject(iidInfo, targetService, targetProperty, targetModule);
+}
+
+/**
+ * 根据IID数组获取规范信息数组
+ * @param {Array} iids - 包含多个IID对象的数组，每个对象格式为 {miid, siid, piid, aiid, eiid}
+ * @returns {Array} - 返回规范对象数组
+ */
+export function getSpecsByIids(iids) {
+  // 参数验证
+  if (!CachedInstance || !Array.isArray(iids) || iids.length === 0) {
+    return [];
+  }
+
+  // 遍历IID数组，获取每个IID对应的规范信息
+  return iids.map(iidInfo => getSpecByIid(iidInfo));
+}