@miot-rn/common-component 1.0.1

package/dist/utils/objects.js

@@ -0,0 +1,222 @@
+import { getType } from "./types";
+const ReactSpecialKeys = new Set(['_owner', '__v', '__o']); // 预定义需跳过的特殊属性
+
+/**
+ * 判断基础类型
+ * @param v
+ * @returns {boolean}
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isPrimary(v) {
+  if (v === null || v === undefined) {
+    return true;
+  }
+  return ['number', 'string', 'boolean', 'symbol'].includes(typeof v);
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+const TypeHandlers = {
+  '[object Array]': {
+    related: false,
+    create: () => {
+      return [];
+    },
+    forEach: (src, fn) => {
+      src.forEach((v, i) => fn(v, i));
+    },
+    map: (src, fn) => {
+      return src.map((v, i) => fn(v, i));
+    },
+    set: (src, key, value) => {
+      src[key] = value;
+    }
+  },
+  '[object Object]': {
+    related: true,
+    create: () => {
+      return {};
+    },
+    forEach: (src, fn) => {
+      Object.entries(src).forEach(([k, v]) => fn(v, k));
+    },
+    map: (src, fn) => {
+      return Object.entries(src).map(([k, v]) => fn(v, k));
+    },
+    set: (src, key, value) => {
+      src[key] = value;
+    }
+  },
+  '[object Set]': {
+    related: false,
+    create: () => {
+      return new Set();
+    },
+    forEach: (src, fn) => {
+      src.forEach(v => fn(v));
+    },
+    map: (src, fn) => {
+      return Array.from(src.entries()).map(vs => fn(vs[0]));
+    },
+    set: (src, key, value) => {
+      src.add(value);
+    }
+  },
+  '[object Map]': {
+    related: true,
+    create: () => {
+      return new Map();
+    },
+    forEach: (src, fn) => {
+      src.forEach((v, k) => fn(v, k));
+    },
+    map: (src, fn) => {
+      return Array.from(src.entries()).map(([k, v]) => fn(v, k));
+    },
+    set: (src, key, value) => {
+      src.set(key, value);
+    }
+  }
+};
+/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _copy(value, memo) {
+  if (isPrimary(value) || value instanceof Function) {
+    return value;
+  }
+  let newValue = memo.get(value);
+  if (newValue) {
+    return newValue;
+  }
+  const type = TypeHandlers[Object.prototype.toString.call(value)];
+  if (type !== undefined) {
+    newValue = type.create();
+    memo.set(value, newValue);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    type.forEach(value, (v, k) => {
+      type.set(newValue, k, _copy(v, memo));
+    });
+  } else {
+    // 不认识的类型默认处理
+    newValue = JSON.parse(JSON.stringify(value));
+  }
+  return newValue;
+}
+
+/**
+ * 深度拷贝函数
+ * 1 基础类型：直接返回原值
+ * 2 数组 or 对象：深copy，支持 Object, Array, Map, Set, Function
+ * @returns {*}
+ * @param value
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function copy(value) {
+  return _copy(value, new Map());
+}
+
+/**
+ * @description 深度比较两个对象是否相等（优化版）基础版本来源：https://github.com/FormidableLabs/react-fast-compare
+ * @author guhao
+ * @param {any} a
+ * @param {any} b
+ * @returns {boolean}
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function deepEqual(a, b) {
+  // 快速相等（包括 +0/-0 和 NaN 处理）
+  if (Object.is(a, b)) return true;
+
+  // 类型检查
+  const typeA = getType(a);
+  const typeB = getType(b);
+  if (typeA !== typeB) return false;
+
+  // 处理非对象类型
+  if (!a || !b || typeof a !== 'object') {
+    return typeA === 'Date' ? a.getTime() === b.getTime() : false;
+  }
+
+  // 构造函数一致性检查
+  if (a.constructor !== b.constructor) return false;
+
+  // 分类型处理
+  switch (typeA) {
+    // 数组处理（反向遍历优化）
+    case 'Array':
+      {
+        if (a.length !== b.length) return false;
+        for (let i = a.length - 1; i >= 0; i--) {
+          if (!deepEqual(a[i], b[i])) return false;
+        }
+        return true;
+      }
+
+    // Date 处理（时间戳比对）
+    case 'Date':
+      return a.getTime() === b.getTime();
+
+    // RegExp 处理（源和标志比对）
+    case 'RegExp':
+      return a.source === b.source && a.flags === b.flags;
+
+    // Map 处理（合并两次遍历为一次）
+    case 'Map':
+      {
+        if (a.size !== b.size) return false;
+        for (const [key, val] of a) {
+          if (!b.has(key) || !deepEqual(val, b.get(key))) return false;
+        }
+        return true;
+      }
+
+    // Set 处理（值存在性检查）
+    case 'Set':
+      {
+        if (a.size !== b.size) return false;
+        for (const val of a) {
+          if (!b.has(val)) return false;
+        }
+        return true;
+      }
+
+    // ArrayBuffer 视图处理（直接内存比对）
+    case 'ArrayBufferView':
+      {
+        const viewA = new DataView(a.buffer, a.byteOffset, a.byteLength);
+        const viewB = new DataView(b.buffer, b.byteOffset, b.byteLength);
+        if (viewA.byteLength !== viewB.byteLength) return false;
+        for (let i = 0; i < viewA.byteLength; i++) {
+          if (viewA.getUint8(i) !== viewB.getUint8(i)) return false;
+        }
+        return true;
+      }
+
+    // 通用对象处理
+    case 'Object':
+      {
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) return false;
+
+        // 使用 Set 优化属性存在性检查
+        const keysBSet = new Set(keysB);
+        for (const key of keysA) {
+          if (!keysBSet.has(key)) return false;
+        }
+
+        // 深度比较属性值（跳过 React 特殊属性）
+        for (const key of keysA) {
+          // @ts-ignore
+          // eslint-disable-next-line no-continue
+          if (ReactSpecialKeys.has(key) && a.$$typeof) continue;
+          if (!deepEqual(a[key], b[key])) return false;
+        }
+        return true;
+      }
+
+    // 其他未处理类型默认返回 false
+    default:
+      return false;
+  }
+}

package/dist/utils/spec.d.ts

@@ -0,0 +1,8 @@
+import { Spec } from '../types';
+export declare function isSpecProp(prop: any): boolean;
+export declare function encodeProp(prop: Spec): string;
+export declare function decodeProp(key: string): any;
+export declare function encodeSceneKey(o: Spec): string;
+export declare function encodeIidsKey(o: Spec): string;
+export declare function specAccess(prop: Spec, type: string): boolean;
+export declare function specsToSubscribeKeys(specs?: Spec[]): string[];

package/dist/utils/spec.js

@@ -0,0 +1,171 @@
+// @ts-ignore
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Device } from 'miot';
+export function isSpecProp(prop) {
+  return !!(prop && prop.siid && typeof prop.siid === 'number');
+}
+
+/**
+ * 需要和服务端保持一致
+ * @param prop
+ * @returns {string}
+ */
+export function encodeProp(prop) {
+  const {
+    miid,
+    siid,
+    piid,
+    aiid,
+    eiid
+  } = prop || {};
+  if (eiid !== null && eiid !== undefined) {
+    return miid ? `event.${miid}.${siid}.${eiid}` : `event.${siid}.${eiid}`;
+  }
+  if (aiid !== null && aiid !== undefined) {
+    return miid ? `action.${miid}.${siid}.${aiid}` : `action.${siid}.${aiid}`;
+  } // if (piid !== null && piid !== undefined) {
+  return miid ? `prop.${miid}.${siid}.${piid}` : `prop.${siid}.${piid}`;
+}
+
+/**
+ * 需要和服务端保持一致
+ * @returns { { siid, piid, aiid, eiid } |null}
+ * @param key
+ */
+export function decodeProp(key) {
+  const res = {};
+  const parts = key.split('.');
+  if (parts.length === 3) {
+    const type = parts[0];
+    const sNumber = parseInt(parts[1], 10);
+    // 2 for '.'
+    const suffix = key.slice(parts[0].length + parts[1].length + 2);
+    const isNotSpec = isNaN(sNumber);
+    const siid = isNotSpec ? parts[1] : sNumber;
+    const xiid = isNotSpec ? suffix : parseInt(suffix, 10);
+    if (type === 'event') {
+      return {
+        siid,
+        eiid: xiid
+      };
+    }
+    if (type === 'action') {
+      return {
+        siid,
+        aiid: xiid
+      };
+    }
+    if (type === 'prop') {
+      return {
+        siid,
+        piid: xiid
+      };
+    }
+  } else if (parts.length >= 4) {
+    const type = parts[0];
+    const mNumber = parseInt(parts[1], 10);
+    const sNumber = parseInt(parts[2], 10);
+    const suffix = key.slice(parts[0].length + parts[1].length + parts[2].length + 3); // 3 for '.'
+    const isNotSpec = isNaN(sNumber);
+    const miid = isNotSpec ? parts[1] : mNumber;
+    const siid = isNotSpec ? parts[2] : sNumber;
+    const xiid = isNotSpec ? suffix : parseInt(suffix, 10);
+    if (type === 'event') {
+      return {
+        miid,
+        siid,
+        eiid: xiid
+      };
+    }
+    if (type === 'action') {
+      return {
+        miid,
+        siid,
+        aiid: xiid
+      };
+    }
+    if (type === 'prop') {
+      return {
+        miid,
+        siid,
+        piid: xiid
+      };
+    }
+  }
+  return res;
+}
+
+/**
+ * 根据spec 获取智能场景的key
+ * @param {object} o
+ * @returns {string}
+ */
+export function encodeSceneKey(o) {
+  if (!o) {
+    return '';
+  }
+  const {
+    miid,
+    siid,
+    piid,
+    aiid,
+    eiid
+  } = o;
+  const type = eiid ? 'event' : aiid ? 'action' : piid ? 'prop' : '';
+  if (!type || !siid) {
+    return '';
+  }
+  return miid ? `${type}.${Device.model}.${miid}.${siid}.${eiid || aiid || piid}` : `${type}.${Device.model}.${siid}.${eiid || aiid || piid}`;
+}
+
+/**
+ * 根据spec 获取iids 组装的key
+ * @param {object} o
+ * @returns {string}
+ */
+export function encodeIidsKey(o) {
+  if (!o) {
+    return '';
+  }
+  const {
+    miid,
+    siid,
+    piid,
+    aiid,
+    eiid
+  } = o;
+  const xiid = eiid || aiid || piid;
+  if (!xiid || !siid) {
+    return '';
+  }
+  return miid ? `${miid}.${siid}.${xiid}` : `${siid}.${xiid}`;
+}
+export function specAccess(prop, type) {
+  if (!prop) {
+    return false;
+  }
+  const access = prop.access || prop.prop?.access || undefined;
+  const gattAccess = prop['gatt-access'] || prop.prop?.['gatt-access'] || undefined;
+  if (
+  // gatt-access 匹配（蓝牙网关上报、插件代报）
+  gattAccess && gattAccess.includes(type) ||
+  // access 匹配时
+  access && access.includes(type)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * 根据spec的订阅key
+ * @param {Array<object>} o
+ * @returns {Array<string>}
+ */
+export function specsToSubscribeKeys(specs = []) {
+  const keys = specs.filter(prop => {
+    return prop && (prop.eiid || specAccess(prop, 'notify')) && (!prop.dataSource || prop.dataSource === 1);
+  }).map(s => {
+    return encodeProp(s);
+  });
+  return keys;
+}

package/dist/utils/types.d.ts

@@ -0,0 +1,3 @@
+export declare const getType: (value: any) => string;
+export declare const isTypeOf: (type: string | string[], value: any) => boolean;
+export declare const isArrayValue: (value: any) => boolean;

package/dist/utils/types.js

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export const getType = value => Object.prototype.toString.call(value).match(/\[object (.*)\]/)[1];
+/**
+ * 判断 value 的类型
+ * @param {string|Array<string>} type
+ * @param {any} value
+ * @returns
+ */
+export const isTypeOf = (type, value) => {
+  const valueType = getType(value);
+  if (Array.isArray(type)) {
+    return type.includes(valueType);
+  }
+  return valueType === type;
+};
+
+/**
+ * @description value是否为array
+ * @param {any} value
+ * @returns {boolean}
+ */
+export const isArrayValue = value => {
+  const valueType = getType(value);
+  return valueType === 'Array';
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@miot-rn/common-component",
+  "version": "1.0.1",
+  "scripts": {
+    "build": "rm -rf dist && rm -f tsconfig.tsbuildinfo && tsc && babel src -d dist --config-file ../../babel.config.js --extensions '.ts,.tsx' --verbose",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "tsc": "rm -f tsconfig.tsbuildinfo && tsc",
+    "format": "prettier --write src/**/*.ts"
+  },
+  "main": "./dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "min_sdk_api_level": 10115,
+  "peerDependencies": {
+    "@types/react": "^16.14.0",
+    "@types/react-native": "^0.61.23",
+    "react": "^16.14.0",
+    "react-native": "0.61.0",
+    "zustand": "^4.4.1"
+  },
+  "gitHead": "3e6285821f0cebb8cdce54ea0e2a6fa624453ef6"
+}