@miot-rn/common-component 1.0.1

package/dist/service/specs/subject.js

@@ -0,0 +1,145 @@
+import { DeviceEventEmitter } from 'react-native';
+import { removeDuplicateIf } from "../../utils/fns";
+import { deepEqual } from "../../utils/objects";
+
+/**
+ * 事件订阅/发布管理器，支持如下功能：
+ * 1 subscribe 订阅 topic、publish 发布 topic、unsubscribeAll 取消所有订阅
+ * 2 设置 Filter，定制事件的发布策略，如取消重复发布、延迟发布等
+ */
+export default class Subject {
+  /**
+   * 创建 Subject
+   * @param keyOf 将 topic 转化为全局唯一的 String
+   * @param handler 可选，自定义订阅/发布的具体实现
+   */
+  constructor(keyOf, handler) {
+    this.keyOf = keyOf;
+    this.subscriptions = new Set();
+    if (handler) {
+      this.handler = handler;
+    } else {
+      // 默认使用 DeviceEvent
+      this.handler = {
+        subscribe: (topic, listener) => {
+          return DeviceEventEmitter.addListener(this.keyOf(topic), listener);
+        },
+        publish: topic => {
+          const key = this.keyOf(topic);
+          DeviceEventEmitter.emit(key, topic);
+        }
+      };
+    }
+  }
+
+  /**
+   * 设置 Filter
+   * @param filter 接口对象，需要实现如下接口 <p/>
+   * 1 setPublisher，设置实际的发布者
+   * 2 accept，判断当前发布的处理转移给filter, true 为转移
+   * 3 reset，重置 filter 的状态
+   */
+  setFilter(filter) {
+    this.filter = filter;
+    if (this.filter && this.filter.setPublisher) {
+      this.filter.setPublisher(this.handler.publish);
+    }
+  }
+
+  /**
+   * 订阅 topic，返回 subscription，其中包含：<p/>
+   * 1 unsubscribe，用于取消监听
+   * 2 isActive，表示该监听是否生效，subscribe - unsubscribe 之间为 true，否则为 false
+   * 2 topics，表示订阅成功的 topic 列表
+   * @param topics
+   * @param listener
+   * @returns {{unsubscribe: subscription.unsubscribe, topics, isActive: (function(): boolean)}}
+   */
+  subscribe(topics, listener) {
+    let subscribed = topics.map(t => {
+      return this.handler.subscribe && this.handler.subscribe(t, listener);
+    }).filter(l => l);
+    const subscription = {
+      unsubscribe: () => {
+        if (subscribed) {
+          subscribed.forEach(l => {
+            l.remove();
+          });
+          subscribed = undefined;
+          this.subscriptions.delete(subscription);
+        }
+      },
+      isActive: () => {
+        return !!subscribed;
+      },
+      topics
+    };
+    this.subscriptions.add(subscription);
+    return subscription;
+  }
+
+  /**
+   * 获取已经订阅的所有 topics
+   * @returns {*[]}
+   */
+  getAllTopics() {
+    let result = [];
+    for (const sub of this.subscriptions) {
+      if (sub.isActive()) {
+        result = result.concat(sub.topics);
+      }
+    }
+    // @ts-ignore
+    removeDuplicateIf(result, ele => this.keyOf(ele));
+    return result;
+  }
+
+  /**
+   * 发布消息
+   *
+   * @param topic
+   * @param active 标识改发布是主动的还是被动的，如果是插件自身触发为主动，如果从云端收到更新为被动
+   * @param callback
+   */
+  publish(topic, active, callback) {
+    const key = this.keyOf(topic);
+    if (this.handler.publish) {
+      if (this.filter && this.filter.accept(key, topic, active, callback)) {
+        // Filter accepted, do nothing
+      } else {
+        callback && callback(topic);
+        this.handler.publish(topic);
+      }
+    }
+  }
+
+  /**
+   * 取消所有订阅
+   */
+  unsubscribeAll() {
+    for (const sub of this.subscriptions) {
+      if (sub.unsubscribe) {
+        sub.unsubscribe();
+        sub.unsubscribe = undefined;
+      }
+    }
+    this.subscriptions && this.subscriptions.clear();
+    this.filter && this.filter.reset && this.filter.reset();
+  }
+}
+export function newSimpleFilter() {
+  let lastValues = {};
+  return {
+    accept: (key, topic) => {
+      const lv = lastValues[key];
+      if (!lv || !deepEqual(topic, lv)) {
+        lastValues[key] = topic;
+        return false;
+      }
+      return true;
+    },
+    reset: () => {
+      lastValues = {};
+    }
+  };
+}

package/dist/service/specs/utils.d.ts

@@ -0,0 +1,28 @@
+import { Spec } from '../../types';
+export declare function mergeProps(props1: Spec[], props2: Spec[], keyOf: (prop: Spec) => string): Spec[];
+export declare function getEventGenerator(name: string, keyOf: (prop: Spec) => string): (prop: Spec) => string;
+export declare function mapError(props: Spec[]): (reason: any) => {
+    message: any;
+    code: any;
+    did?: string | undefined;
+    siid: number;
+    piid?: number | undefined;
+    aiid?: number | undefined;
+    miid?: number | undefined;
+    value?: any;
+    in?: any[] | undefined;
+    dataSource?: number | undefined;
+}[];
+export declare function genError(prop: Spec): (reason: any) => {
+    message: any;
+    code: any;
+    did?: string | undefined;
+    siid: number;
+    piid?: number | undefined;
+    aiid?: number | undefined;
+    miid?: number | undefined;
+    value?: any;
+    in?: any[] | undefined;
+    dataSource?: number | undefined;
+};
+export declare function reduceResults(results: any[]): any;

package/dist/service/specs/utils.js

@@ -0,0 +1,46 @@
+import { PLUGIN_UNKNOWN_ERROR } from "./error-code";
+export function mergeProps(props1, props2, keyOf) {
+  const cache = props2.reduce((acc, cur) => {
+    acc.set(keyOf(cur), cur);
+    return acc;
+  }, new Map());
+  return props1.map(p1 => {
+    const p2 = cache.get(keyOf(p1));
+    return p2 ? {
+      ...p1,
+      ...p2
+    } : null;
+  }).filter(p => !!p);
+}
+export function getEventGenerator(name, keyOf) {
+  return prop => {
+    return name ? `__${name}__${keyOf(prop)}` : `${keyOf(prop)}`;
+  };
+}
+export function mapError(props) {
+  return reason => {
+    const code = reason.code !== undefined ? reason.code : PLUGIN_UNKNOWN_ERROR;
+    return props.map(prop => {
+      return {
+        ...prop,
+        message: reason,
+        code
+      };
+    });
+  };
+}
+export function genError(prop) {
+  return reason => {
+    const code = reason.code !== undefined ? reason.code : PLUGIN_UNKNOWN_ERROR;
+    return {
+      ...prop,
+      message: reason,
+      code
+    };
+  };
+}
+export function reduceResults(results) {
+  return (results || []).reduce((preProps, curProps) => {
+    return [...preProps, ...curProps];
+  }, []);
+}

package/dist/specs/i18n-parser.d.ts

@@ -0,0 +1,10 @@
+import { Spec } from '../types';
+export declare function init(i18n: any): void;
+export declare function getI18n(): any;
+export declare function getLocalI18n(key: string, replaces?: any[]): string | Record<string, string>;
+export declare function mergeI18n(...i18ns: any[]): any;
+export declare function getI18nKey(spec: Spec): string;
+export declare function getI18nForSpecs(specs: Spec[], fn?: (...args: any[]) => any, lang?: string): string;
+export declare function getI18nForSpecValue(spec: Spec, value: any, fn?: (...args: any[]) => any, lang?: string): string;
+export declare function getI18nListForSpecs(spec: Spec, lang?: string): any[];
+export declare function transformUnit(unit: string, long?: boolean): string;

package/dist/specs/i18n-parser.js

@@ -0,0 +1,300 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+// spec多语言 服务，在init 初始化后，可以通过各方法拉取功能定义的文案和内置文案
+
+// @ts-ignore
+import { Host } from 'miot';
+import { i18ns as LocalI18ns } from "../resources/i18n";
+import getValueOrDefault from "../utils/get-value-or-default";
+import { getPluralRules } from "../utils/i18n";
+import { getIndexBySpecValue } from "./instance-parser";
+import { isTypeOf } from "../utils/types";
+let CachedI18n = null;
+const defaultLang = 'en';
+
+/* eslint-disable camelcase */
+const LangMap = {
+  nl: 'nl_NL',
+  tr: 'tr_TR',
+  zh: 'zh_cn',
+  pt: 'pt_BR',
+  el: 'el_gr',
+  cs: 'cs_cz',
+  ro: 'ro_ro',
+  uk: 'uk_ua',
+  sv: 'sv_SE',
+  es_us: 'es_US',
+  nb: 'nb_NO',
+  fi: 'fi_FI'
+};
+/* eslint-enable camelcase */
+
+const FlagMap = {
+  module: 'module',
+  service: 'service',
+  property: 'property',
+  valuelist: 'valuelist',
+  action: 'action',
+  event: 'event'
+};
+
+/**
+ * 文案处理函数类型定义
+ * @typedef {function(string[], string): string} I18nProcessor
+ * @param {string[]} specI18ns - 多语言文案数组
+ * @param {string} lang - 当前语言
+ * @returns {string} 处理后的文案
+ */
+
+function setCachedI18n(i18n) {
+  CachedI18n = i18n;
+}
+
+/**
+ * 根据功能定义对应的多语言，进行初始化，方便后续根据siid, piid 等信息直接拿对应spec 的文案
+ * @param {object} 多语言 {en: {}, zh_cn: {}}
+ * @return {void}
+ */
+export function init(i18n) {
+  setCachedI18n(i18n);
+}
+export function getI18n() {
+  return CachedI18n;
+}
+
+/**
+ * 根据key 和替换规则，返回内置多语言文案
+ * @param {string} key 内置多语言（assets/i18n）中定义的文案的key
+ * @param {replaces} key 对应的内置文案中，将通用占位符${} 依次替换为replaces 中的文本或占位符
+ * @return {string} 替换后的文案
+ */
+export function getLocalI18n(key, replaces = []) {
+  const lang = Host.locale.language;
+  const firstNumber = replaces.find(v => isTypeOf('Number', v));
+  const isNumber = typeof firstNumber === 'number';
+  const localI18n = LocalI18ns[lang] || LocalI18ns[defaultLang] || {};
+  let target = localI18n[key];
+  if (!target) {
+    return '';
+  }
+  // 不区分单复数的，直接替换
+  if (!isTypeOf('Object', target)) {
+    let result = target;
+    replaces.forEach((r, i) => {
+      result = result.replace('${}', r);
+      result = result.replace(`{${i + 1}}`, r);
+    });
+    return result;
+  }
+  // 区分单复数的
+  // 如果第一个参数是数字，则取最终值
+  if (isNumber) {
+    const targetObj = target;
+    let result = targetObj[getPluralRules(lang, firstNumber)];
+    replaces.forEach((r, i) => {
+      result = result.replace('${}', r);
+      result = result.replace(`{${i + 1}}`, r);
+    });
+    return result;
+  }
+  // 如果不是数字（比如占位符或其他文案），则把每一项都替换，在实际使用时由控件的i18n.get 处理
+  return Object.entries(target).reduce((ret, [k, v]) => {
+    return {
+      ...ret,
+      [k]: (v => {
+        let result = v;
+        replaces.forEach((r, i) => {
+          result = result.replace('${}', r);
+          result = result.replace(`{${i + 1}}`, r);
+        });
+        return result;
+      })(v)
+    };
+  }, {});
+}
+
+/**
+ * 将多个文案配置依次合并成一个，后者相对于前者的差异部分，替换或新增
+ * 注意：参数中不需要带有语言标识
+ * @param {object} 文案配置，如{title: 'xxx'}，支持多个参数依次列开
+ * @return {object} 合并后的配置
+ */
+export function mergeI18n(...i18ns) {
+  return i18ns.reduce((ret, i18n) => {
+    return {
+      ...ret,
+      ...(i18n || {})
+    };
+  }, {});
+}
+function getI18nKeyFlag(type, n) {
+  const nLength = String(n).length;
+  const id = nLength <= 2 ? `000${n}`.slice(-3) : String(n);
+  return `${type}:${id}`;
+}
+export function getI18nKey(spec) {
+  if (!spec) {
+    return '';
+  }
+  const {
+    miid,
+    siid,
+    piid,
+    aiid,
+    eiid
+  } = spec;
+  const viid = spec.viid;
+  const keyFlags = [];
+  if (miid) {
+    keyFlags.push(getI18nKeyFlag(FlagMap.module, miid));
+  }
+  if (siid) {
+    keyFlags.push(getI18nKeyFlag(FlagMap.service, siid));
+  }
+  if (piid) {
+    keyFlags.push(getI18nKeyFlag(FlagMap.property, piid));
+
+    // value 比较特殊，是从0开始的序号
+    if (viid || viid === 0) {
+      keyFlags.push(getI18nKeyFlag(FlagMap.valuelist, viid));
+    }
+  }
+  if (aiid) {
+    keyFlags.push(getI18nKeyFlag(FlagMap.action, aiid));
+  }
+  if (eiid) {
+    keyFlags.push(getI18nKeyFlag(FlagMap.event, eiid));
+  }
+  return keyFlags.join(':');
+}
+
+/**
+ * 通过传入的specs 获取对应的功能定义文案，若有fn 则根据fn 对文案进行处理
+ * @param {array} specs 支持service({siid}), property({siid, piid}), valuelist({siid, piid, viid}), action({siid, aiid}), event({siid, eiid})
+ * @param {function} fn 对拿到的功能定义的文案进行额外处理
+ * @return {string} 最终返回的文案
+ */
+export function getI18nForSpecs(specs, fn, lang = Host.locale.language) {
+  if (!CachedI18n) {
+    return '';
+  }
+  const i18n = CachedI18n[LangMap[lang] || lang] || CachedI18n[defaultLang] || CachedI18n.zh_cn || {};
+  // if (!i18n) {
+  //   return '';
+  // }
+  const keys = specs.map(spec => {
+    const i18nKey = getI18nKey(spec);
+    return i18nKey;
+  });
+  const specI18ns = keys.map(key => {
+    return i18n[key] || (CachedI18n[defaultLang] ? CachedI18n[defaultLang][key] : '') || (CachedI18n.zh_cn ? CachedI18n.zh_cn[key] : '') || '';
+  });
+  if (!(fn instanceof Function)) {
+    return specI18ns[0];
+  }
+  return fn(specI18ns, lang);
+}
+
+/**
+ * 根据传入的spec和value获取对应value的spec文案
+ * 该方法通过调用instance-parser中的getIndexBySpecValue方法获取value对应的index，
+ * 并将该index作为viid参数传递给getI18nForSpecs方法，实现根据spec和value获取对应文案的功能
+ *
+ * @param {SpecObject} spec - 包含规范的对象，支持property({siid, piid})
+ * @param {any} value - 要查找的目标值，通常为数字类型
+ * @param {I18nProcessor} [fn] - 对拿到的功能定义的文案进行额外处理的函数
+ * @param {string} [lang=Host.locale.language] - 目标语言，默认为当前设备语言
+ * @return {string} 最终返回的文案，如果找不到对应的value或spec无效则返回空字符串
+ *
+ * @example
+ * // 获取座椅加热档位的文案
+ * const spec = { siid: 2, piid: 1 };
+ * const value = 2; // 对应Level 2
+ * const text = getI18nForSpecValue(spec, value);
+ * // 返回 "Level 2" 或对应的本地化文案
+ */
+export function getI18nForSpecValue(spec, value, fn, lang = Host.locale.language) {
+  // 参数验证，提高代码健壮性
+  if (!spec || value === undefined || value === null) {
+    return '';
+  }
+
+  // 通过spec和value获取对应的index（viid）
+  // 这里复用instance-parser中已有的getIndexBySpecValue方法，保证逻辑一致性
+  const viid = getIndexBySpecValue(spec, value);
+
+  // 如果找不到对应的value，返回空字符串
+  if (viid === -1) {
+    return '';
+  }
+  // 构建包含viid的spec对象
+  // 使用对象展开运算符保持原有spec的其他属性不变
+  const specWithViid = {
+    ...spec,
+    viid: viid + 1
+  };
+
+  // 调用getI18nForSpecs获取对应的文案
+  // 传入数组格式以保持接口一致性
+  return getI18nForSpecs([specWithViid], fn, lang);
+}
+
+/**
+ * 通过传入的spec 获取对应的功能定义文案列表
+ * @param {array} spec
+ * @return {array} 最终返回的文案列表
+ */
+export function getI18nListForSpecs(spec, lang = Host.locale.language) {
+  if (!CachedI18n) {
+    return [];
+  }
+  let i18n = CachedI18n[LangMap[lang] || lang] || CachedI18n[defaultLang] || CachedI18n.zh_cn || {};
+  if (Object.keys(i18n).length === 0) i18n = CachedI18n.zh_cn;
+  const flag = getI18nKey(spec);
+  const ans = [];
+  if (!i18n || typeof flag !== 'string') return ans;
+  for (const key in i18n) {
+    if (key.includes(flag) && key.includes('valuelist') && key.split(':').length > 0) {
+      ans.push({
+        num: Number(key.split(':').reverse()[0]),
+        desc: i18n[key] || (CachedI18n[defaultLang] ? CachedI18n[defaultLang][key] : '') || (CachedI18n.zh_cn ? CachedI18n.zh_cn[key] : '') || ''
+      });
+    }
+  }
+  return ans;
+}
+
+/**
+ * 根据spec 属性的unit, 获取多语言处理后的文案或标识
+ */
+export function transformUnit(unit, long) {
+  const kvs = {
+    percentage: '%',
+    rgb: '',
+    kelvin: 'k',
+    pascal: 'Pa',
+    arcdegress: '°',
+    watt: 'w',
+    L: 'L',
+    ppm: 'ppm',
+    lux: 'lux',
+    'mg/m3': 'mg/m3',
+    celsius: '℃',
+    none: '',
+    get m() {
+      return getLocalI18n('common_meter');
+    },
+    get seconds() {
+      return getLocalI18n('seconds');
+    },
+    get minutes() {
+      return long ? getLocalI18n('minutesFull') : getLocalI18n('minutes');
+    },
+    get hours() {
+      return long ? getLocalI18n('hoursFull') : getLocalI18n('hours');
+    },
+    get days() {
+      return getLocalI18n('days');
+    }
+  };
+  return getValueOrDefault(kvs, unit, unit) || '';
+}

package/dist/specs/instance-parser.d.ts

@@ -0,0 +1,26 @@
+import { Spec, QuerySpecParams } from '../types';
+export declare function init(instance?: any): void;
+export declare function getInstance(): any;
+export declare function getSpecVersion(): number;
+export declare function getDynamicType(): number;
+export declare function getValidModules(): any[];
+export declare function parseSpecType(type: string): {
+    key: string;
+    version: number;
+};
+export declare function getSpecs(keys: QuerySpecParams[]): Spec[][];
+export declare function getSpecsOnly(keys: QuerySpecParams[]): (Spec | null)[];
+export declare function getSpecOnly(key: QuerySpecParams): Spec | null;
+export declare function getSpecsIidsOnly(specs: Spec[]): Spec[];
+export declare function getIndexBySpecValue(spec: any, targetValue: any): number;
+export declare function getSpecValueList(spec: Spec): any[];
+export declare function getValueBySpecDescription(spec: Spec, description: string): any;
+export declare function getSpecValueRange(spec: Spec): any[];
+export declare function getIndexBySpecDescription(spec: Spec, description: string): number;
+export declare function getValueBySpecDescriptions(spec: Spec, descriptions?: string[]): any;
+export declare function getIdleIndex(spec: Spec): number;
+export declare function getKeyIndexOfInstance(instance: any, search: {
+    skey: string;
+    pkey: string;
+}): [number, number];
+export declare function getSpecsByIids(iids: any[]): any[];