diff --git a/packages/inula/__tests__/HorizonXTest/adapters/ReduxReactAdapter.test.tsx b/packages/inula/__tests__/HorizonXTest/adapters/ReduxReactAdapter.test.tsx
index b03ea1f5..ea9b58e0 100644
--- a/packages/inula/__tests__/HorizonXTest/adapters/ReduxReactAdapter.test.tsx
+++ b/packages/inula/__tests__/HorizonXTest/adapters/ReduxReactAdapter.test.tsx
@@ -375,4 +375,93 @@ describe('Redux/React binding adapter', () => {
expect(getE(BUTTON).innerHTML).toBe('1');
expect(getE(BUTTON2).innerHTML).toBe('true');
});
+
+ it('Nested use of connect', () => {
+ const updateInfo = [];
+ let dispatchMethod;
+ const ChildComponent = ({ childData, dispatch }) => {
+ const isMount = Inula.useRef(false);
+
+ Inula.useEffect(() => {
+ if (!isMount.current) {
+ isMount.current = true;
+ } else {
+ updateInfo.push('ChildComponent Updated');
+ }
+ });
+ dispatchMethod = dispatch;
+
+ return (
+
+
Child Component
+
{childData}
+
+
Parent Component
+
{parentData}
+
+
= S | Dispatch;
+
+const defaultMerge = (...args: any[]) => {
+ return Object.assign({}, ...args);
+};
+
+interface ReduxSelector {
+ dependsOnOwnProps: boolean;
+
+ (stateOrDispatch?: StateOrDispatch, ownProps?: OwnProps): any;
+}
+
+const isDependsOnOwnProps = (propsMapping: any) => {
+ return propsMapping.dependsOnOwnProps ? Boolean(propsMapping.dependsOnOwnProps) : propsMapping.length !== 1;
+};
+
+function handleMapToProps(
+ mapStateToProps?: MapStateToPropsP
+): ReduxSelector {
+ if (typeof mapStateToProps === 'function') {
+ const proxy = <
+ ReduxSelector & {
+ mapToProps: any;
+ }
+ >function mapToPropsProxy(stateOrDispatch: StateOrDispatch, ownProps?: any) {
+ return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch);
+ };
+ proxy.dependsOnOwnProps = true;
+
+ proxy.mapToProps = function (stateOrDispatch: StateOrDispatch, ownProps: any) {
+ proxy.mapToProps = mapStateToProps;
+ proxy.dependsOnOwnProps = isDependsOnOwnProps(mapStateToProps);
+ let props = proxy(stateOrDispatch, ownProps);
+
+ if (typeof props === 'function') {
+ props.mapToProps = props;
+ proxy.dependsOnOwnProps = isDependsOnOwnProps(props);
+ props = proxy(stateOrDispatch, ownProps);
+ }
+ return props;
+ };
+ return proxy;
+ } else {
+ const selector = () => {
+ return {};
+ };
+ selector.dependsOnOwnProps = false;
+ return selector;
+ }
+}
+
+function handleMapDispatchToProps(
+ dispatch: Dispatch,
+ mapDispatchToProps?: MapDispatchToPropsP
+): ReduxSelector {
+ if (!mapDispatchToProps) {
+ const selector = () => {
+ return { dispatch: dispatch };
+ };
+ selector.dependsOnOwnProps = false;
+ return selector;
+ } else if (typeof mapDispatchToProps === 'function') {
+ return handleMapToProps(mapDispatchToProps);
+ } else {
+ const selector = () => {
+ const mappedDispatch = {};
+ Object.entries(mapDispatchToProps).forEach(([key, value]) => {
+ mappedDispatch[key] = (...args: ReduxAction[]) => {
+ dispatch(value(...args));
+ };
+ });
+ return mappedDispatch;
+ };
+ selector.dependsOnOwnProps = false;
+ return selector;
+ }
+}
+
+function getSelector(
+ store: ReduxStoreHandler,
+ {
+ mapStateToProps,
+ mapDispatchToProps,
+ mergeProps,
+ options,
+ }: {
+ mapStateToProps: MapStateToPropsP;
+ mapDispatchToProps?: MapDispatchToPropsP;
+ mergeProps?: MergePropsP;
+ options: ConnectOption;
+ }
+) {
+ const { dispatch } = store;
+ const mappedStateToProps = handleMapToProps(mapStateToProps);
+ const mappedDispatchToProps = handleMapDispatchToProps(dispatch, mapDispatchToProps);
+ const mergeMethod = mergeProps || defaultMerge;
+
+ return pureSelectorCreator(mappedStateToProps, mappedDispatchToProps, mergeMethod, dispatch, options);
+}
+
+function pureSelectorCreator(
+ mapStateToProps: ReduxSelector,
+ mapDispatchToProps: ReduxSelector,
+ mergeProps: MergePropsP,
+ dispatch: Dispatch,
+ options: ConnectOption
+) {
+ let hasRun = false;
+ let state: any;
+ let ownProps: OwnProps;
+ let stateProps: StateProps;
+ let dispatchProps: DispatchProps;
+ let mergedProps: MergedProps;
+
+ const { areStatesEqual = isSame, areOwnPropsEqual = shallowCompare, areStatePropsEqual = shallowCompare } = options;
+
+ // 首次运行该函数
+ function firstRun(initState: any, initOwnProps: OwnProps) {
+ state = initState;
+ ownProps = initOwnProps;
+ stateProps = mapStateToProps(state, ownProps);
+ dispatchProps = mapDispatchToProps(dispatch, ownProps);
+ mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
+ hasRun = true;
+ return mergedProps;
+ }
+
+ function duplicateRun(newState: any, newOwnProps: OwnProps) {
+ const isStateChange = !areStatesEqual(newState, state);
+ const isPropsChange = !areOwnPropsEqual(newOwnProps, ownProps);
+ state = newState;
+ ownProps = newOwnProps;
+ if (isStateChange && isPropsChange) {
+ stateProps = mapStateToProps(state, ownProps);
+ if (mapDispatchToProps.dependsOnOwnProps) {
+ dispatchProps = mapDispatchToProps(dispatch, ownProps);
+ }
+ mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
+ return mergedProps;
+ }
+ if (isPropsChange) {
+ if (mapStateToProps.dependsOnOwnProps) {
+ stateProps = mapStateToProps(state, ownProps);
+ }
+ if (mapDispatchToProps.dependsOnOwnProps) {
+ dispatchProps = mapDispatchToProps(dispatch, ownProps);
+ }
+ mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
+ return mergedProps;
+ }
+ if (isStateChange) {
+ const latestStateProps = mapStateToProps(state, ownProps);
+ const isStatePropsChange = !areStatePropsEqual(latestStateProps, stateProps);
+ stateProps = latestStateProps;
+ if (isStatePropsChange) {
+ mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
+ }
+ return mergedProps;
+ }
+ return mergedProps;
+ }
+
+ return function (newState: any, newOwnProps: OwnProps) {
+ return hasRun ? duplicateRun(newState, newOwnProps) : firstRun(newState, newOwnProps);
+ };
+}
+
+export { getSelector };
diff --git a/packages/inula/src/inulax/adapters/subscription.ts b/packages/inula/src/inulax/adapters/subscription.ts
new file mode 100644
index 00000000..5f5f6a94
--- /dev/null
+++ b/packages/inula/src/inulax/adapters/subscription.ts
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2024 Huawei Technologies Co.,Ltd.
+ *
+ * openInula is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ * http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+import { unstable_batchedUpdates } from '../../dom/DOMExternal';
+import { ReduxStoreHandler } from './redux';
+
+type LinkListNode = {
+ next: LinkListNode;
+ prev: LinkListNode;
+ value: T;
+} | null;
+
+type CallBack = () => void;
+
+interface ListenerManager {
+ clear(): void;
+
+ trigger(): void;
+
+ subscribe(cb: CallBack): () => void;
+}
+
+function batchUpdate(callback: () => any) {
+ unstable_batchedUpdates(callback);
+}
+
+function getLinkedList() {
+ let firstNode: LinkListNode = null;
+ let lastNode: LinkListNode = null;
+
+ function clear() {
+ firstNode = null;
+ lastNode = null;
+ }
+
+ function getIterator(): T[] {
+ const data: T[] = [];
+ let curNode = firstNode;
+ while (curNode) {
+ data.push(curNode.value);
+ curNode = curNode.next;
+ }
+ return data;
+ }
+
+ function add(element: T): NonNullable> {
+ let newNode: LinkListNode;
+ if (!firstNode || !lastNode) {
+ newNode = {
+ value: element,
+ prev: null,
+ next: null,
+ };
+ firstNode = lastNode = newNode;
+ return newNode;
+ } else {
+ newNode = {
+ value: element,
+ prev: lastNode,
+ next: null,
+ };
+ lastNode.next = newNode;
+ lastNode = newNode;
+ return newNode;
+ }
+ }
+
+ function removeNode(node: NonNullable>) {
+ if (node.next) {
+ node.next.prev = node.prev;
+ } else {
+ lastNode = node.prev;
+ }
+ if (node.prev) {
+ node.prev.next = node.next;
+ } else {
+ firstNode = node.next;
+ }
+ }
+
+ return {
+ add,
+ clear,
+ removeNode,
+ getIterator,
+ };
+}
+
+function getListenerManager(): ListenerManager {
+ const linkedList = getLinkedList();
+
+ function subscribe(cb: CallBack): () => void {
+ const listener = linkedList.add(cb);
+ return () => linkedList.removeNode(listener);
+ }
+
+ function trigger() {
+ const listeners = linkedList.getIterator();
+ batchUpdate(() => {
+ for (const listener of listeners) {
+ listener();
+ }
+ });
+ }
+
+ function clear() {
+ linkedList.clear();
+ }
+
+ return {
+ clear,
+ trigger,
+ subscribe,
+ };
+}
+
+export interface Subscription {
+ stateChange?: () => any;
+
+ addNestedSub(listener: CallBack): CallBack;
+
+ triggerNestedSubs(): void;
+
+ trySubscribe(): void;
+
+ tryUnsubscribe(): void;
+}
+
+const nullListenerStore = {} as unknown as ListenerManager;
+
+function createSubscription(store: ReduxStoreHandler, parentSub: Subscription | null = null): Subscription {
+ let unsubscribe: CallBack | undefined;
+ let listenerStore: ListenerManager = nullListenerStore;
+
+ function addNestedSub(listener: CallBack) {
+ trySubscribe();
+ return listenerStore.subscribe(listener);
+ }
+
+ function triggerNestedSubs() {
+ listenerStore.trigger();
+ }
+
+ function storeChangeHandler() {
+ if (typeof subscription.stateChange === 'function') {
+ subscription.stateChange();
+ }
+ }
+
+ function trySubscribe() {
+ if (!unsubscribe) {
+ unsubscribe = parentSub ? parentSub.addNestedSub(storeChangeHandler) : store.subscribe(storeChangeHandler);
+ listenerStore = getListenerManager();
+ }
+ }
+
+ function tryUnsubscribe() {
+ if (typeof unsubscribe === 'function') {
+ unsubscribe();
+ unsubscribe = undefined;
+ listenerStore.clear();
+ listenerStore = nullListenerStore;
+ }
+ }
+
+ const subscription: Subscription = {
+ stateChange: undefined,
+ addNestedSub,
+ triggerNestedSubs,
+ trySubscribe,
+ tryUnsubscribe,
+ };
+
+ return subscription;
+}
+
+export default createSubscription;
diff --git a/packages/inula/src/types.ts b/packages/inula/src/types.ts
index cd42165a..67db6d32 100644
--- a/packages/inula/src/types.ts
+++ b/packages/inula/src/types.ts
@@ -103,7 +103,7 @@ export interface ChildrenType {
toArray(children: InulaNode | InulaNode[]): Array>;
}
-type ForwardRef = ((inst: T | null) => void) | MutableRef | null;
+export type ForwardRef = ((inst: T | null) => void) | MutableRef | null;
export interface ForwardRefRenderFunc {
(props: P, ref: ForwardRef): InulaElement | null;