@international-iot-association/rct-state 3.0.0-rc.1

package/README.md

@@ -0,0 +1,87 @@
+# @international-iot-association/rct-state
+
+Legend-State 风格的 RxJS + Immutable 响应式状态库，供工位插件的 React UI 使用。
+属于**组 A · 协议锁步组**（与 `plugin-contracts`/`plugin-sdk`/`api-bridge` 一起随 `agentApi` major 锁步发布）。
+
+## 安装
+
+```bash
+npm i @international-iot-association/rct-state
+```
+
+## Usage
+
+Basic usage for pure JavaScript:
+
+```tsx
+// file: userData.ts
+
+import { observable } from 'rct-state';
+
+// define type for state
+interface User {
+  id: number;
+  name: string;
+}
+
+const user: User = {
+  id: 1,
+  name: 'jojo',
+}
+
+// create store
+export const user$ = observable(user);
+
+// get user id
+const userId = user$.id.get();
+
+// set user id
+user$.id.set(99);
+
+// watch user id change
+user$.observe((state) => {
+  return state.id
+}, (id) => {
+  console.log('user id changed:', id)
+})
+
+```
+
+Basic usage for React Native or React component:
+
+```tsx
+import React from 'react';
+import { View, Text } from 'react-native'
+import { user$ } from './userData'
+
+
+export function UserPanel() {
+  const { id, name } = user$.use()
+  const userId = user$.id.use()
+  const username = user$.useSelector((state) => state.id)
+
+  // watch value change
+  user$.useObserve((state) => state.name, username => {
+    console.log(`user name changed: ${username}`)
+  })
+
+  return (
+    <View>
+      <Text>ID: { id }</Text>
+      <Text>Name: { name }</Text>
+    </View>
+  )
+}
+```
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/dist/index.cjs

@@ -0,0 +1,554 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createDeepProxy: () => createDeepProxy,
+  observable: () => observable
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/proxy/wrapper.ts
+var Wrapper = class {
+  value;
+  keyPath = [];
+  originalObject;
+  onSet;
+  onUse;
+  proxy = new Proxy(this, {
+    get(target, property) {
+      if (property in target) {
+        return target[property];
+      } else {
+        return target.value;
+      }
+    }
+  });
+  constructor(value, keyPath = [], originalObject, onSet, onUse) {
+    this.value = value;
+    this.keyPath = keyPath;
+    this.originalObject = originalObject;
+    this.onSet = onSet;
+    this.onUse = onUse;
+    return this.proxy;
+  }
+  valueOf() {
+    return this.value;
+  }
+  get() {
+    return this.peek();
+  }
+  peek() {
+    const value = this.originalObject().getIn(this.keyPath);
+    if (typeof value === "function") {
+      return value.bind(this.originalObject)();
+    } else {
+      return value;
+    }
+  }
+  get __keyPath() {
+    return this.keyPath;
+  }
+  get __self() {
+    return {
+      value: this.value,
+      keyPath: this.keyPath
+    };
+  }
+  toString() {
+    return this.keyPath.join(".");
+  }
+  toJSON() {
+    return JSON.stringify(this.keyPath);
+  }
+  set(value) {
+    this.onSet(value, this.keyPath);
+  }
+  use() {
+    return this.onUse(this.keyPath);
+  }
+};
+
+// src/proxy/wrapObject.ts
+var import_immutable = __toESM(require("immutable"), 1);
+function wrapObject(obj, keyPath = [], originalObject, onSet, onUse, _2) {
+  return new Proxy(obj, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "get":
+          return () => originalObject().getIn(keyPath);
+        case "peek":
+          return () => originalObject().getIn(keyPath);
+        case "set":
+          return (value) => {
+            onSet && onSet(value, keyPath);
+          };
+        case "use":
+          return () => {
+            return onUse(keyPath);
+          };
+        case "__keyPath":
+          return keyPath;
+        case "isImmutableList":
+          return import_immutable.default.isList(target);
+        case "isImmutableMap":
+          return import_immutable.default.isMap(target);
+        case "__self":
+          return target;
+        // list functions
+        case "delete":
+        case "remove":
+          return (value) => {
+            if (import_immutable.default.isList(originalObject().getIn(keyPath))) {
+              originalObject().getIn(keyPath).delete(value);
+            }
+          };
+        case "push":
+          return (...values) => {
+            const targetList = originalObject().getIn(keyPath);
+            if (!import_immutable.default.isList(targetList) && !Array.isArray(targetList)) {
+              return;
+            }
+            onSet && onSet([...targetList, ...values], keyPath);
+          };
+        // default
+        default:
+          return Reflect.get(target, prop, receiver);
+      }
+    }
+  });
+}
+
+// src/proxy/index.ts
+function createDeepProxy(target, path = [], originalObject, onSet, onUse, notifyChange) {
+  return new Proxy(target, {
+    get(_target, property) {
+      if (property === "__self") {
+        return _target;
+      }
+      const keyPath = path.concat([property.toString()]);
+      const realValue = originalObject().getIn(keyPath);
+      if (typeof realValue === "object" && realValue !== null) {
+        return wrapObject(
+          // @ts-ignore
+          createDeepProxy(
+            realValue,
+            path.concat([property.toString()]),
+            originalObject,
+            onSet,
+            onUse
+          ),
+          keyPath,
+          originalObject,
+          onSet,
+          onUse,
+          notifyChange
+          // realValue
+        );
+      }
+      return new Wrapper(realValue, keyPath, originalObject, onSet, onUse);
+    },
+    set(_target, property, value, receiver) {
+      return Reflect.set(_target, property, value, receiver);
+    }
+  });
+}
+
+// src/manager.ts
+var import_rxjs2 = require("rxjs");
+
+// src/hooks/use.ts
+var import_react2 = require("react");
+var import_react_fast_compare2 = __toESM(require("react-fast-compare"), 1);
+
+// src/utils/subscribe.ts
+var import_react_fast_compare = __toESM(require("react-fast-compare"), 1);
+var import_rxjs = require("rxjs");
+var import_lodash = __toESM(require("lodash"), 1);
+function generateSubForSpecificChange(config) {
+  const defaultValue = config.subject.value ? config.subject.value : config.defaultData ? config.filter(config.defaultData) : void 0;
+  const defaultFilteredData = defaultValue !== void 0 ? config.filter(defaultValue) : void 0;
+  const sub = config.subject.pipe(
+    (0, import_rxjs.startWith)(void 0),
+    (0, import_rxjs.map)((data) => {
+      if (data === void 0) {
+        return void 0;
+      }
+      return import_lodash.default.cloneDeep(config.filter(data));
+    }),
+    (0, import_rxjs.pairwise)(),
+    (0, import_rxjs.filter)(([prev, next]) => {
+      return !(0, import_react_fast_compare.default)(prev, next);
+    }),
+    (0, import_rxjs.defaultIfEmpty)([defaultFilteredData, defaultFilteredData])
+  );
+  return sub;
+}
+
+// src/hooks/useState.ts
+var import_react = require("react");
+var import_lodash2 = require("lodash");
+
+// src/utils/isSSR.ts
+var isBrowser = typeof window !== "undefined";
+var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isSSR = !(isBrowser || isReactNative);
+
+// src/hooks/useState.ts
+function useStateForClient(initialState) {
+  const stateValue = (0, import_react.useRef)(initialState || {});
+  const [state, _setState] = (0, import_react.useState)(initialState);
+  const setState = (value) => {
+    const valueIsFunction = typeof value === "function";
+    const targetValue = valueIsFunction ? value(stateValue.current) : value;
+    if (!(0, import_lodash2.isEqual)(targetValue, stateValue.current)) {
+      stateValue.current = targetValue;
+      _setState(targetValue);
+    }
+  };
+  return [state, setState];
+}
+var useState = isSSR ? import_react.useState : useStateForClient;
+
+// src/hooks/use.ts
+function useFunc({ keyPath, subSource, getState }) {
+  const valueRef = (0, import_react2.useRef)(getState().getIn(keyPath));
+  const [value, _setValue] = useState(valueRef.current);
+  const setValue = (0, import_react2.useCallback)((nextValue) => {
+    if (!(0, import_react_fast_compare2.default)(valueRef.current, nextValue)) {
+      valueRef.current = nextValue;
+      _setValue(nextValue);
+    }
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    const sub = generateSubForSpecificChange({
+      subject: subSource,
+      filter: () => {
+        return getState().getIn(keyPath);
+      },
+      mark: "useFunc"
+    }).subscribe(([_2, next]) => {
+      setValue(next);
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  }, [keyPath, subSource, getState]);
+  return value;
+}
+
+// src/hooks/useObserve.ts
+var import_react3 = require("react");
+
+// src/proxy/immutableGetter.ts
+var import_immutable2 = require("immutable");
+function createProxiedList(list) {
+  return new Proxy(list, {
+    get(target, key) {
+      const numKey = Number(key);
+      if (key === "__self") {
+        return target;
+      }
+      if (key === "isImmutableList") {
+        return true;
+      }
+      if (Number.isNaN(numKey)) {
+        return Reflect.get(target, key);
+      }
+      const value = target.get(numKey);
+      if (import_immutable2.Map.isMap(value)) {
+        return createProxiedMap(value);
+      } else if (import_immutable2.List.isList(value)) {
+        return createProxiedList(value);
+      }
+      return value;
+    },
+    set(target, key, value) {
+      const numKey = Number(key);
+      if (Number.isNaN(numKey)) {
+        return false;
+      }
+      target.set(numKey, value);
+      return true;
+    }
+  });
+}
+function createProxiedMap(map2) {
+  return new Proxy(map2, {
+    get(target, key) {
+      const mapValue = target.get(key);
+      if (mapValue === void 0) {
+        return mapValue;
+      }
+      if (key === "__self") {
+        return target;
+      }
+      if (key === "isImmutableMap") {
+        return true;
+      }
+      if (import_immutable2.Map.isMap(mapValue)) {
+        return createProxiedMap(
+          mapValue
+        );
+      } else if (import_immutable2.List.isList(mapValue)) {
+        return createProxiedList(
+          mapValue
+        );
+      }
+      return mapValue;
+    },
+    set(target, key, value) {
+      target.set(key, value);
+      return true;
+    }
+  });
+}
+function wrapGetterForMap(data) {
+  return createProxiedMap(data);
+}
+function wrapAsImmutable(data) {
+  const mapData = (0, import_immutable2.Map)(data);
+  return {
+    getter: createProxiedMap(mapData),
+    mapData
+  };
+}
+
+// src/hooks/useObserve.ts
+function useObserve({
+  selectorFunction,
+  subSource,
+  onChangeFunction,
+  getState
+}) {
+  (0, import_react3.useEffect)(() => {
+    const sub = generateSubForSpecificChange({
+      subject: subSource,
+      filter: () => {
+        return selectorFunction(wrapGetterForMap(getState()));
+      },
+      mark: "useObserve"
+    }).subscribe(([_2, next]) => {
+      onChangeFunction(next);
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  }, [subSource, getState, onChangeFunction, selectorFunction]);
+}
+
+// src/hooks/useSelector.ts
+var import_react4 = require("react");
+
+// src/utils/isImmutableObject.ts
+var IMMUTABLE_ITERABLE = "@@__IMMUTABLE_ITERABLE__@@";
+var IMMUTABLE_RECORD = "@@__IMMUTABLE_RECORD__@@";
+var IMMUTABLE_LIST = "@@__IMMUTABLE_LIST__@@";
+var IMMUTABLE_MAP = "@@__IMMUTABLE_MAP__@@";
+function isImmutableObject(obj) {
+  if (typeof obj !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(obj);
+  if (proto[IMMUTABLE_ITERABLE] || proto[IMMUTABLE_RECORD] || proto[IMMUTABLE_LIST] || proto[IMMUTABLE_MAP]) {
+    return true;
+  }
+  return false;
+}
+
+// src/hooks/useSelector.ts
+function useSelector({
+  selectorFunction,
+  subSource,
+  getState
+}) {
+  const wrappedSelectorFunction = (0, import_react4.useCallback)(
+    (getJS = false) => () => {
+      const state = getState();
+      const res = selectorFunction(wrapGetterForMap(state));
+      if (isImmutableObject(res)) {
+        if (getJS) {
+          return state.toJS();
+        }
+        return state;
+      }
+      return res;
+    },
+    [selectorFunction, getState]
+  );
+  const [value, setValue] = useState(wrappedSelectorFunction(true)());
+  (0, import_react4.useEffect)(() => {
+    const sub = generateSubForSpecificChange({
+      subject: subSource,
+      filter: wrappedSelectorFunction(),
+      mark: "useSelector"
+    }).subscribe(([_2, next]) => {
+      if (isImmutableObject(next)) {
+        setValue(next.toJS());
+      } else {
+        setValue(next);
+      }
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  }, [wrappedSelectorFunction, getState, subSource]);
+  return value;
+}
+
+// src/manager.ts
+var ObserverableManager = class {
+  state;
+  subject;
+  _state$;
+  batchProcessing = false;
+  stateGetter;
+  get state$() {
+    return new Proxy(this._state$, {
+      get: (target, property, receiver) => {
+        switch (property) {
+          case "useSelector":
+            return this.useSelector;
+          case "useObserve":
+            return this.useObserve;
+          case "batch":
+            return this.batch;
+          case "peek":
+            return this.peek;
+          case "observe":
+            return this.observe;
+          case "__immutable__":
+            return this.state;
+          default:
+            return Reflect.get(target, property, receiver);
+        }
+      },
+      set: () => {
+        return false;
+      }
+    });
+  }
+  constructor(state) {
+    const wrappedState = wrapAsImmutable(state);
+    this.state = wrappedState.mapData;
+    this.stateGetter = wrappedState.getter;
+    this.subject = new import_rxjs2.BehaviorSubject(this.state);
+    this._state$ = createDeepProxy(
+      state,
+      [],
+      this.getCurrentState,
+      this.onSet,
+      this.onUse,
+      this.notifyChange
+    );
+  }
+  /**
+   * This method will be utilized by the 'get' method of the Proxy and the subscription logic within hooks,
+   * with the aim of obtaining the latest 'state' reference.
+   * @returns
+   */
+  getCurrentState = () => {
+    return this.state;
+  };
+  onSet = (value, keyPath) => {
+    this.state = this.state.setIn(keyPath, value);
+    this.notifyChange();
+  };
+  notifyChange = () => {
+    if (this.batchProcessing) {
+      return;
+    }
+    this.subject.next(this.state);
+  };
+  onUse = (keyPath) => {
+    return useFunc({
+      keyPath,
+      subSource: this.subject,
+      getState: this.getCurrentState
+    });
+  };
+  useSelector = (selector) => {
+    return useSelector({
+      selectorFunction: selector,
+      subSource: this.subject,
+      getState: this.getCurrentState
+    });
+  };
+  useObserve = (selector, onChange) => {
+    useObserve({
+      selectorFunction: selector,
+      subSource: this.subject,
+      onChangeFunction: onChange,
+      getState: this.getCurrentState
+    });
+  };
+  batch = (batchAction) => {
+    this.batchProcessing = true;
+    batchAction();
+    this.batchProcessing = false;
+    this.notifyChange();
+  };
+  peek = () => {
+    return this.state.toJS();
+  };
+  get = () => {
+    return this.peek();
+  };
+  observe = (selector, onChange) => {
+    const sub = generateSubForSpecificChange({
+      subject: this.subject,
+      filter: () => {
+        const res = selector(wrapGetterForMap(this.state));
+        return res;
+      }
+    }).subscribe(([_2, next]) => {
+      onChange(next);
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  };
+};
+function observable(state) {
+  return new ObserverableManager(state).state$;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDeepProxy,
+  observable
+});

package/dist/index.d.cts

@@ -0,0 +1,59 @@
+import Immutable from 'immutable';
+
+declare class Wrapper<T extends any> {
+    value: any;
+    keyPath: string[];
+    originalObject: () => Immutable.Map<keyof T, T[keyof T]>;
+    onSet: OnSet<T>;
+    onUse: OnUse<T>;
+    private proxy;
+    constructor(value: any, keyPath: string[] | undefined, originalObject: () => Immutable.Map<keyof T, T[keyof T]>, onSet: OnSet<T>, onUse: OnUse<T>);
+    valueOf(): any;
+    get(): T extends (...args: any[]) => infer R ? R : T;
+    peek(): T extends (...args: any[]) => infer R ? R : T;
+    get __keyPath(): string[];
+    get __self(): {
+        value: any;
+        keyPath: string[];
+    };
+    toString(): string;
+    toJSON(): string;
+    set(value: T): void;
+    use(): T;
+}
+
+type Unwrap<T> = T extends Wrapper<infer U> ? U : T;
+type FunctionType = (...args: any[]) => any;
+type WrapTypeForNormal<P extends object> = {
+    get(): P extends (...args: any[]) => infer R ? R : P;
+    peek(): P extends (...args: any[]) => infer R ? R : P;
+    set(value: P): void;
+    use(): P;
+    __keyPath: string[];
+};
+type WrapTypeForFunc<P extends object> = {
+    get(): P extends (...args: any[]) => infer R ? R : P;
+    peek(): P extends (...args: any[]) => infer R ? R : P;
+    use(): P;
+    __keyPath: string[];
+};
+type WrapType<T extends object, P extends object> = (P extends FunctionType ? WrapTypeForFunc<P> : WrapTypeForNormal<P>) & T;
+type DeepProxy<T> = {
+    [P in keyof T]: T[P] extends object ? WrapType<DeepProxy<T[P]>, T[P]> : Wrapper<T[P]>;
+};
+type OnSet<T extends any> = (value: T, keyPath: string[]) => void;
+type OnUse<T extends any> = (keyPath: string[]) => T;
+
+declare function createDeepProxy<T extends object>(target: T, path: string[] | undefined, originalObject: () => Immutable.Map<keyof T, T[keyof T]>, onSet: OnSet<T>, onUse: OnUse<T>, notifyChange: () => void): DeepProxy<T>;
+
+type Observable<T> = DeepProxy<T> & {
+    useSelector: <R>(selector: (state: T) => R) => Unwrap<R>;
+    useObserve: <P>(selector: (state: T) => P, onChange: (value: Unwrap<P>) => void) => void;
+    batch: (batchAction: () => void) => void;
+    peek: () => T;
+    observe: <P>(selector: (state: T) => P, onChange: (value: P) => void) => () => void;
+    __immutable__: Immutable.Map<keyof T, T[keyof T]>;
+};
+declare function observable<T extends object>(state: T): Observable<T>;
+
+export { type DeepProxy, type Observable, createDeepProxy, observable };

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import Immutable from 'immutable';
+
+declare class Wrapper<T extends any> {
+    value: any;
+    keyPath: string[];
+    originalObject: () => Immutable.Map<keyof T, T[keyof T]>;
+    onSet: OnSet<T>;
+    onUse: OnUse<T>;
+    private proxy;
+    constructor(value: any, keyPath: string[] | undefined, originalObject: () => Immutable.Map<keyof T, T[keyof T]>, onSet: OnSet<T>, onUse: OnUse<T>);
+    valueOf(): any;
+    get(): T extends (...args: any[]) => infer R ? R : T;
+    peek(): T extends (...args: any[]) => infer R ? R : T;
+    get __keyPath(): string[];
+    get __self(): {
+        value: any;
+        keyPath: string[];
+    };
+    toString(): string;
+    toJSON(): string;
+    set(value: T): void;
+    use(): T;
+}
+
+type Unwrap<T> = T extends Wrapper<infer U> ? U : T;
+type FunctionType = (...args: any[]) => any;
+type WrapTypeForNormal<P extends object> = {
+    get(): P extends (...args: any[]) => infer R ? R : P;
+    peek(): P extends (...args: any[]) => infer R ? R : P;
+    set(value: P): void;
+    use(): P;
+    __keyPath: string[];
+};
+type WrapTypeForFunc<P extends object> = {
+    get(): P extends (...args: any[]) => infer R ? R : P;
+    peek(): P extends (...args: any[]) => infer R ? R : P;
+    use(): P;
+    __keyPath: string[];
+};
+type WrapType<T extends object, P extends object> = (P extends FunctionType ? WrapTypeForFunc<P> : WrapTypeForNormal<P>) & T;
+type DeepProxy<T> = {
+    [P in keyof T]: T[P] extends object ? WrapType<DeepProxy<T[P]>, T[P]> : Wrapper<T[P]>;
+};
+type OnSet<T extends any> = (value: T, keyPath: string[]) => void;
+type OnUse<T extends any> = (keyPath: string[]) => T;
+
+declare function createDeepProxy<T extends object>(target: T, path: string[] | undefined, originalObject: () => Immutable.Map<keyof T, T[keyof T]>, onSet: OnSet<T>, onUse: OnUse<T>, notifyChange: () => void): DeepProxy<T>;
+
+type Observable<T> = DeepProxy<T> & {
+    useSelector: <R>(selector: (state: T) => R) => Unwrap<R>;
+    useObserve: <P>(selector: (state: T) => P, onChange: (value: Unwrap<P>) => void) => void;
+    batch: (batchAction: () => void) => void;
+    peek: () => T;
+    observe: <P>(selector: (state: T) => P, onChange: (value: P) => void) => () => void;
+    __immutable__: Immutable.Map<keyof T, T[keyof T]>;
+};
+declare function observable<T extends object>(state: T): Observable<T>;
+
+export { type DeepProxy, type Observable, createDeepProxy, observable };

package/dist/index.js

@@ -0,0 +1,522 @@
+// src/proxy/wrapper.ts
+var Wrapper = class {
+  value;
+  keyPath = [];
+  originalObject;
+  onSet;
+  onUse;
+  proxy = new Proxy(this, {
+    get(target, property) {
+      if (property in target) {
+        return target[property];
+      } else {
+        return target.value;
+      }
+    }
+  });
+  constructor(value, keyPath = [], originalObject, onSet, onUse) {
+    this.value = value;
+    this.keyPath = keyPath;
+    this.originalObject = originalObject;
+    this.onSet = onSet;
+    this.onUse = onUse;
+    return this.proxy;
+  }
+  valueOf() {
+    return this.value;
+  }
+  get() {
+    return this.peek();
+  }
+  peek() {
+    const value = this.originalObject().getIn(this.keyPath);
+    if (typeof value === "function") {
+      return value.bind(this.originalObject)();
+    } else {
+      return value;
+    }
+  }
+  get __keyPath() {
+    return this.keyPath;
+  }
+  get __self() {
+    return {
+      value: this.value,
+      keyPath: this.keyPath
+    };
+  }
+  toString() {
+    return this.keyPath.join(".");
+  }
+  toJSON() {
+    return JSON.stringify(this.keyPath);
+  }
+  set(value) {
+    this.onSet(value, this.keyPath);
+  }
+  use() {
+    return this.onUse(this.keyPath);
+  }
+};
+
+// src/proxy/wrapObject.ts
+import Immutable from "immutable";
+function wrapObject(obj, keyPath = [], originalObject, onSet, onUse, _2) {
+  return new Proxy(obj, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "get":
+          return () => originalObject().getIn(keyPath);
+        case "peek":
+          return () => originalObject().getIn(keyPath);
+        case "set":
+          return (value) => {
+            onSet && onSet(value, keyPath);
+          };
+        case "use":
+          return () => {
+            return onUse(keyPath);
+          };
+        case "__keyPath":
+          return keyPath;
+        case "isImmutableList":
+          return Immutable.isList(target);
+        case "isImmutableMap":
+          return Immutable.isMap(target);
+        case "__self":
+          return target;
+        // list functions
+        case "delete":
+        case "remove":
+          return (value) => {
+            if (Immutable.isList(originalObject().getIn(keyPath))) {
+              originalObject().getIn(keyPath).delete(value);
+            }
+          };
+        case "push":
+          return (...values) => {
+            const targetList = originalObject().getIn(keyPath);
+            if (!Immutable.isList(targetList) && !Array.isArray(targetList)) {
+              return;
+            }
+            onSet && onSet([...targetList, ...values], keyPath);
+          };
+        // default
+        default:
+          return Reflect.get(target, prop, receiver);
+      }
+    }
+  });
+}
+
+// src/proxy/index.ts
+function createDeepProxy(target, path = [], originalObject, onSet, onUse, notifyChange) {
+  return new Proxy(target, {
+    get(_target, property) {
+      if (property === "__self") {
+        return _target;
+      }
+      const keyPath = path.concat([property.toString()]);
+      const realValue = originalObject().getIn(keyPath);
+      if (typeof realValue === "object" && realValue !== null) {
+        return wrapObject(
+          // @ts-ignore
+          createDeepProxy(
+            realValue,
+            path.concat([property.toString()]),
+            originalObject,
+            onSet,
+            onUse
+          ),
+          keyPath,
+          originalObject,
+          onSet,
+          onUse,
+          notifyChange
+          // realValue
+        );
+      }
+      return new Wrapper(realValue, keyPath, originalObject, onSet, onUse);
+    },
+    set(_target, property, value, receiver) {
+      return Reflect.set(_target, property, value, receiver);
+    }
+  });
+}
+
+// src/manager.ts
+import { BehaviorSubject } from "rxjs";
+
+// src/hooks/use.ts
+import { useCallback, useEffect, useRef as useRef2 } from "react";
+import isEqual3 from "react-fast-compare";
+
+// src/utils/subscribe.ts
+import isEqual from "react-fast-compare";
+import {
+  defaultIfEmpty,
+  filter,
+  map,
+  pairwise,
+  startWith
+} from "rxjs";
+import _ from "lodash";
+function generateSubForSpecificChange(config) {
+  const defaultValue = config.subject.value ? config.subject.value : config.defaultData ? config.filter(config.defaultData) : void 0;
+  const defaultFilteredData = defaultValue !== void 0 ? config.filter(defaultValue) : void 0;
+  const sub = config.subject.pipe(
+    startWith(void 0),
+    map((data) => {
+      if (data === void 0) {
+        return void 0;
+      }
+      return _.cloneDeep(config.filter(data));
+    }),
+    pairwise(),
+    filter(([prev, next]) => {
+      return !isEqual(prev, next);
+    }),
+    defaultIfEmpty([defaultFilteredData, defaultFilteredData])
+  );
+  return sub;
+}
+
+// src/hooks/useState.ts
+import { useRef, useState as ReactUseState } from "react";
+import { isEqual as isEqual2 } from "lodash";
+
+// src/utils/isSSR.ts
+var isBrowser = typeof window !== "undefined";
+var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isSSR = !(isBrowser || isReactNative);
+
+// src/hooks/useState.ts
+function useStateForClient(initialState) {
+  const stateValue = useRef(initialState || {});
+  const [state, _setState] = ReactUseState(initialState);
+  const setState = (value) => {
+    const valueIsFunction = typeof value === "function";
+    const targetValue = valueIsFunction ? value(stateValue.current) : value;
+    if (!isEqual2(targetValue, stateValue.current)) {
+      stateValue.current = targetValue;
+      _setState(targetValue);
+    }
+  };
+  return [state, setState];
+}
+var useState = isSSR ? ReactUseState : useStateForClient;
+
+// src/hooks/use.ts
+function useFunc({ keyPath, subSource, getState }) {
+  const valueRef = useRef2(getState().getIn(keyPath));
+  const [value, _setValue] = useState(valueRef.current);
+  const setValue = useCallback((nextValue) => {
+    if (!isEqual3(valueRef.current, nextValue)) {
+      valueRef.current = nextValue;
+      _setValue(nextValue);
+    }
+  }, []);
+  useEffect(() => {
+    const sub = generateSubForSpecificChange({
+      subject: subSource,
+      filter: () => {
+        return getState().getIn(keyPath);
+      },
+      mark: "useFunc"
+    }).subscribe(([_2, next]) => {
+      setValue(next);
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  }, [keyPath, subSource, getState]);
+  return value;
+}
+
+// src/hooks/useObserve.ts
+import { useEffect as useEffect2 } from "react";
+
+// src/proxy/immutableGetter.ts
+import { Map, List } from "immutable";
+function createProxiedList(list) {
+  return new Proxy(list, {
+    get(target, key) {
+      const numKey = Number(key);
+      if (key === "__self") {
+        return target;
+      }
+      if (key === "isImmutableList") {
+        return true;
+      }
+      if (Number.isNaN(numKey)) {
+        return Reflect.get(target, key);
+      }
+      const value = target.get(numKey);
+      if (Map.isMap(value)) {
+        return createProxiedMap(value);
+      } else if (List.isList(value)) {
+        return createProxiedList(value);
+      }
+      return value;
+    },
+    set(target, key, value) {
+      const numKey = Number(key);
+      if (Number.isNaN(numKey)) {
+        return false;
+      }
+      target.set(numKey, value);
+      return true;
+    }
+  });
+}
+function createProxiedMap(map2) {
+  return new Proxy(map2, {
+    get(target, key) {
+      const mapValue = target.get(key);
+      if (mapValue === void 0) {
+        return mapValue;
+      }
+      if (key === "__self") {
+        return target;
+      }
+      if (key === "isImmutableMap") {
+        return true;
+      }
+      if (Map.isMap(mapValue)) {
+        return createProxiedMap(
+          mapValue
+        );
+      } else if (List.isList(mapValue)) {
+        return createProxiedList(
+          mapValue
+        );
+      }
+      return mapValue;
+    },
+    set(target, key, value) {
+      target.set(key, value);
+      return true;
+    }
+  });
+}
+function wrapGetterForMap(data) {
+  return createProxiedMap(data);
+}
+function wrapAsImmutable(data) {
+  const mapData = Map(data);
+  return {
+    getter: createProxiedMap(mapData),
+    mapData
+  };
+}
+
+// src/hooks/useObserve.ts
+function useObserve({
+  selectorFunction,
+  subSource,
+  onChangeFunction,
+  getState
+}) {
+  useEffect2(() => {
+    const sub = generateSubForSpecificChange({
+      subject: subSource,
+      filter: () => {
+        return selectorFunction(wrapGetterForMap(getState()));
+      },
+      mark: "useObserve"
+    }).subscribe(([_2, next]) => {
+      onChangeFunction(next);
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  }, [subSource, getState, onChangeFunction, selectorFunction]);
+}
+
+// src/hooks/useSelector.ts
+import { useCallback as useCallback2, useEffect as useEffect3 } from "react";
+
+// src/utils/isImmutableObject.ts
+var IMMUTABLE_ITERABLE = "@@__IMMUTABLE_ITERABLE__@@";
+var IMMUTABLE_RECORD = "@@__IMMUTABLE_RECORD__@@";
+var IMMUTABLE_LIST = "@@__IMMUTABLE_LIST__@@";
+var IMMUTABLE_MAP = "@@__IMMUTABLE_MAP__@@";
+function isImmutableObject(obj) {
+  if (typeof obj !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(obj);
+  if (proto[IMMUTABLE_ITERABLE] || proto[IMMUTABLE_RECORD] || proto[IMMUTABLE_LIST] || proto[IMMUTABLE_MAP]) {
+    return true;
+  }
+  return false;
+}
+
+// src/hooks/useSelector.ts
+function useSelector({
+  selectorFunction,
+  subSource,
+  getState
+}) {
+  const wrappedSelectorFunction = useCallback2(
+    (getJS = false) => () => {
+      const state = getState();
+      const res = selectorFunction(wrapGetterForMap(state));
+      if (isImmutableObject(res)) {
+        if (getJS) {
+          return state.toJS();
+        }
+        return state;
+      }
+      return res;
+    },
+    [selectorFunction, getState]
+  );
+  const [value, setValue] = useState(wrappedSelectorFunction(true)());
+  useEffect3(() => {
+    const sub = generateSubForSpecificChange({
+      subject: subSource,
+      filter: wrappedSelectorFunction(),
+      mark: "useSelector"
+    }).subscribe(([_2, next]) => {
+      if (isImmutableObject(next)) {
+        setValue(next.toJS());
+      } else {
+        setValue(next);
+      }
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  }, [wrappedSelectorFunction, getState, subSource]);
+  return value;
+}
+
+// src/manager.ts
+var ObserverableManager = class {
+  state;
+  subject;
+  _state$;
+  batchProcessing = false;
+  stateGetter;
+  get state$() {
+    return new Proxy(this._state$, {
+      get: (target, property, receiver) => {
+        switch (property) {
+          case "useSelector":
+            return this.useSelector;
+          case "useObserve":
+            return this.useObserve;
+          case "batch":
+            return this.batch;
+          case "peek":
+            return this.peek;
+          case "observe":
+            return this.observe;
+          case "__immutable__":
+            return this.state;
+          default:
+            return Reflect.get(target, property, receiver);
+        }
+      },
+      set: () => {
+        return false;
+      }
+    });
+  }
+  constructor(state) {
+    const wrappedState = wrapAsImmutable(state);
+    this.state = wrappedState.mapData;
+    this.stateGetter = wrappedState.getter;
+    this.subject = new BehaviorSubject(this.state);
+    this._state$ = createDeepProxy(
+      state,
+      [],
+      this.getCurrentState,
+      this.onSet,
+      this.onUse,
+      this.notifyChange
+    );
+  }
+  /**
+   * This method will be utilized by the 'get' method of the Proxy and the subscription logic within hooks,
+   * with the aim of obtaining the latest 'state' reference.
+   * @returns
+   */
+  getCurrentState = () => {
+    return this.state;
+  };
+  onSet = (value, keyPath) => {
+    this.state = this.state.setIn(keyPath, value);
+    this.notifyChange();
+  };
+  notifyChange = () => {
+    if (this.batchProcessing) {
+      return;
+    }
+    this.subject.next(this.state);
+  };
+  onUse = (keyPath) => {
+    return useFunc({
+      keyPath,
+      subSource: this.subject,
+      getState: this.getCurrentState
+    });
+  };
+  useSelector = (selector) => {
+    return useSelector({
+      selectorFunction: selector,
+      subSource: this.subject,
+      getState: this.getCurrentState
+    });
+  };
+  useObserve = (selector, onChange) => {
+    useObserve({
+      selectorFunction: selector,
+      subSource: this.subject,
+      onChangeFunction: onChange,
+      getState: this.getCurrentState
+    });
+  };
+  batch = (batchAction) => {
+    this.batchProcessing = true;
+    batchAction();
+    this.batchProcessing = false;
+    this.notifyChange();
+  };
+  peek = () => {
+    return this.state.toJS();
+  };
+  get = () => {
+    return this.peek();
+  };
+  observe = (selector, onChange) => {
+    const sub = generateSubForSpecificChange({
+      subject: this.subject,
+      filter: () => {
+        const res = selector(wrapGetterForMap(this.state));
+        return res;
+      }
+    }).subscribe(([_2, next]) => {
+      onChange(next);
+    });
+    return () => {
+      if (sub && sub.unsubscribe) {
+        sub.unsubscribe();
+      }
+    };
+  };
+};
+function observable(state) {
+  return new ObserverableManager(state).state$;
+}
+export {
+  createDeepProxy,
+  observable
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@international-iot-association/rct-state",
+  "version": "3.0.0-rc.1",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/International-IoT-Association/MES.git",
+    "directory": "electron-station-plugins/packages/rct-state"
+  },
+  "description": "Legend-State 风格的 RxJS + Immutable 响应式状态库。",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist .turbo"
+  },
+  "dependencies": {
+    "immutable": "^4.3.2",
+    "lodash": "^4.17.21",
+    "react-fast-compare": "^3.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "devDependencies": {
+    "@international-iot-association/tsconfig": "1.0.0-rc.1",
+    "@types/lodash": "^4.17.13",
+    "@types/react": "^19.2.7",
+    "react": "^19.2.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.3"
+  },
+  "x-internal-version": "1.0.0",
+  "x-source-revision": "410a2f3b85ef03b678f04f22ea0a47718f5ddae1"
+}