@my-react/react-reconciler-compact 0.0.1

package/dist/types/api/append.d.ts

@@ -0,0 +1,4 @@
+import type { ReconcilerDispatch } from "../dispatch";
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+export declare const append: (_dispatch: ReconcilerDispatch, _fiber: MyReactFiberNode, _config: any) => void;
+//# sourceMappingURL=append.d.ts.map

package/dist/types/api/append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../../../src/api/append.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAE1F,eAAO,MAAM,MAAM,cAAe,kBAAkB,UAAU,gBAAgB,WAAW,GAAG,SA6C3F,CAAC"}

package/dist/types/api/create.d.ts

@@ -0,0 +1,4 @@
+import type { ReconcilerDispatch } from "../dispatch";
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+export declare const create: (_dispatch: ReconcilerDispatch, _fiber: MyReactFiberNode, _config: any) => void;
+//# sourceMappingURL=create.d.ts.map

package/dist/types/api/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/api/create.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAyB,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE1F,eAAO,MAAM,MAAM,cAAe,kBAAkB,UAAU,gBAAgB,WAAW,GAAG,SAoC3F,CAAC"}

package/dist/types/api/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./ref";
+export * from "./create";
+export * from "./append";
+export * from "./update";
+export * from "./remove";
+export * from "./position";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/dist/types/api/position.d.ts

@@ -0,0 +1,4 @@
+import type { ReconcilerDispatch } from "../dispatch";
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+export declare const position: (_dispatch: ReconcilerDispatch, _fiber: MyReactFiberNode, _config: any) => void;
+//# sourceMappingURL=position.d.ts.map

package/dist/types/api/position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["../../../src/api/position.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AA6G1F,eAAO,MAAM,QAAQ,cAAe,kBAAkB,UAAU,gBAAgB,WAAW,GAAG,SAgB7F,CAAC"}

package/dist/types/api/ref.d.ts

@@ -0,0 +1,10 @@
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+/**
+ * @internal
+ */
+export declare const setRef: (_fiber: MyReactFiberNode, config: any) => void;
+/**
+ * @internal
+ */
+export declare const unsetRef: (_fiber: MyReactFiberNode) => void;
+//# sourceMappingURL=ref.d.ts.map

package/dist/types/api/ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../../src/api/ref.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;GAEG;AACH,eAAO,MAAM,MAAM,WAAY,gBAAgB,UAAU,GAAG,SAgD3D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,WAAY,gBAAgB,SAoBhD,CAAC"}

package/dist/types/api/remove.d.ts

@@ -0,0 +1,4 @@
+import type { ReconcilerDispatch } from "../dispatch";
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+export declare const remove: (_dispatch: ReconcilerDispatch, _fiber: MyReactFiberNode, _config: any) => void;
+//# sourceMappingURL=remove.d.ts.map

package/dist/types/api/remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../src/api/remove.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAE1F,eAAO,MAAM,MAAM,cAAe,kBAAkB,UAAU,gBAAgB,WAAW,GAAG,SAyB3F,CAAC"}

package/dist/types/api/update.d.ts

@@ -0,0 +1,4 @@
+import { type MyReactFiberNode } from "@my-react/react-reconciler";
+import type { ReconcilerDispatch } from "../dispatch";
+export declare const update: (_dispatch: ReconcilerDispatch, _fiber: MyReactFiberNode, _config: any) => void;
+//# sourceMappingURL=update.d.ts.map

package/dist/types/api/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/api/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAG9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,eAAO,MAAM,MAAM,cAAe,kBAAkB,UAAU,gBAAgB,WAAW,GAAG,SAkC3F,CAAC"}

package/dist/types/devtool.d.ts

@@ -0,0 +1,7 @@
+import type { CustomRenderDispatch } from "@my-react/react-reconciler";
+export declare const DISPATCH_FIELD = "__@my-react/dispatch__";
+export declare const DEV_TOOL_FIELD = "__@my-react/react-devtool-inject__";
+export declare const addGlobalDispatch: (dispatch: CustomRenderDispatch) => void;
+export declare const autoSetDevTools: (dispatch: CustomRenderDispatch) => void;
+export declare const delGlobalDispatch: (dispatch: CustomRenderDispatch) => void;
+//# sourceMappingURL=devtool.d.ts.map

package/dist/types/devtool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtool.d.ts","sourceRoot":"","sources":["../../src/devtool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,eAAO,MAAM,cAAc,2BAA2B,CAAC;AAEvD,eAAO,MAAM,cAAc,uCAAuC,CAAC;AAEnE,eAAO,MAAM,iBAAiB,aAAc,oBAAoB,SAU/D,CAAC;AAEF,eAAO,MAAM,eAAe,aAAc,oBAAoB,SAY7D,CAAC;AAEF,eAAO,MAAM,iBAAiB,aAAc,oBAAoB,SAM/D,CAAC"}

package/dist/types/dispatch.d.ts

@@ -0,0 +1,326 @@
+import { NODE_TYPE } from "@my-react/react-reconciler";
+import type { MyReactElementNode, RenderHookParams, UpdateQueue } from "@my-react/react";
+import type { MyReactFiberRoot, MyReactFiberNode } from "@my-react/react-reconciler";
+import type { ListTree } from "@my-react/react-shared";
+export declare const createDispatch: (rootNode: any, rootFiber: MyReactFiberRoot, rootElement: MyReactElementNode, config: any) => {
+    enableUpdate: boolean;
+    enableAsyncLoad: boolean;
+    runtimeDom: {
+        hostContextMap: WeakMap<MyReactFiberNode, any>;
+        elementMap: WeakMap<MyReactFiberNode, MyReactFiberNode>;
+    };
+    runtimeRef: Record<"typeForRef" | "typeForCreate" | "typeForUpdate" | "typeForAppend" | "typeForNativeNode", NODE_TYPE>;
+    dispatchFiber(_fiber: MyReactFiberNode): void;
+    commitCreate(_fiber: MyReactFiberNode): void;
+    commitUpdate(_fiber: MyReactFiberNode): void;
+    commitAppend(_fiber: MyReactFiberNode): void;
+    commitPosition(_fiber: MyReactFiberNode): void;
+    commitSetRef(_fiber: MyReactFiberNode): void;
+    commitUnsetRef(_fiber: MyReactFiberNode): void;
+    commitClear(_fiber: MyReactFiberNode): void;
+    reconcileCommit(_fiber: MyReactFiberNode): void;
+    reconcileUpdate(_list: ListTree<MyReactFiberNode>): void;
+    patchToFiberInitial(_fiber: MyReactFiberNode): void;
+    patchToFiberUnmount(_fiber: MyReactFiberNode): void;
+    dispatchState(_params: UpdateQueue): void;
+    dispatchHook(_params: RenderHookParams): unknown;
+    dispatchPromise(_params: {
+        fiber?: MyReactFiberNode;
+        promise?: Promise<unknown>;
+    }): MyReactElementNode;
+    dispatchError(_params: {
+        fiber?: MyReactFiberNode;
+        error?: Error;
+    }): MyReactElementNode;
+    readonly rootNode: any;
+    readonly rootFiber: MyReactFiberNode;
+    isAppMounted: boolean;
+    isAppCrashed: boolean;
+    isAppUnmounted: boolean;
+    version: string;
+    mode: string;
+    enableNewEntry: boolean;
+    renderMode: string;
+    renderPackage?: string;
+    pendingCommitFiberList: ListTree<MyReactFiberNode>;
+    pendingCommitFiberPatch: import("@my-react/react-shared").PATCH_TYPE;
+    pendingAsyncLoadList: ListTree<MyReactFiberNode | Promise<any>>;
+    pendingChangedFiberList: ListTree<MyReactFiberNode>;
+    pendingUpdateFiberArray: import("@my-react/react-shared").UniqueArray<MyReactFiberNode>;
+    performanceLogTimeLimit: number;
+    uniqueIdCount: number;
+    beforeCommit?: () => void;
+    afterCommit?: () => void;
+    beforeUpdate?: () => void;
+    afterUpdate?: () => void;
+    beforeUnmount?: () => void;
+    afterUnmount?: () => void;
+    generateCommitList(_fiber: MyReactFiberNode): void;
+    generateChangedList(_fiber: MyReactFiberNode, withCheck?: boolean): void;
+    pendingCreate(_fiber: MyReactFiberNode): void;
+    pendingUpdate(_fiber: MyReactFiberNode): void;
+    pendingAppend(_fiber: MyReactFiberNode): void;
+    pendingPosition(_fiber: MyReactFiberNode): void;
+    pendingRef(_fiber: MyReactFiberNode): void;
+    pendingUnmount(_fiber: MyReactFiberNode, _pendingUnmount: MyReactFiberNode): void;
+    pendingEffect(_fiber: MyReactFiberNode, _effect: () => void, option?: {
+        stickyToHead?: boolean;
+        stickyToFoot?: boolean;
+    }): void;
+    pendingLayoutEffect(_fiber: MyReactFiberNode, _layoutEffect: () => void, option?: {
+        stickyToHead?: boolean;
+        stickyToFoot?: boolean;
+    }): void;
+    pendingInsertionEffect(_fiber: MyReactFiberNode, _insertionEffect: () => void, option?: {
+        stickyToHead?: boolean;
+        stickyToFoot?: boolean;
+    }): void;
+    patchToFiberUpdate(_fiber: MyReactFiberNode): void;
+    processFiber(_fiber: MyReactFiberNode): Promise<void>;
+    processPromise(_promise: import("@my-react/react-reconciler").PromiseWithState<unknown>): Promise<void>;
+    resolveStrict(_fiber: MyReactFiberNode): boolean;
+    resolveScope(_fiber: MyReactFiberNode): MyReactFiberNode;
+    resolveSuspenseValue(_fiber: MyReactFiberNode): MyReactElementNode;
+    resolveSuspenseFiber(_fiber: MyReactFiberNode): MyReactFiberNode;
+    resolveErrorBoundaries(_fiber: MyReactFiberNode): MyReactFiberNode;
+    resolveContextFiber(_fiber: MyReactFiberNode, _contextObject: import("@my-react/react").ContextObjectType<{
+        $$typeof: symbol;
+        value: unknown;
+        Context: {
+            $$typeof: symbol;
+            displayName: string;
+        };
+    }, {
+        $$typeof: symbol;
+        Context: {
+            $$typeof: symbol;
+            displayName: string;
+        };
+    }>): MyReactFiberNode;
+    resolveContextValue(_fiber: MyReactFiberNode, _contextObject: import("@my-react/react").ContextObjectType<{
+        $$typeof: symbol;
+        value: unknown;
+        Context: {
+            $$typeof: symbol;
+            displayName: string;
+        };
+    }, {
+        $$typeof: symbol;
+        Context: {
+            $$typeof: symbol;
+            displayName: string;
+        };
+    }>): Record<string, unknown>;
+    reconcileUnmount(): void;
+    shouldYield(): boolean;
+    resetUpdateFlowRuntimeFiber(): void;
+    getFiberTree(_fiber: MyReactFiberNode): string;
+    readPromise(_params: Promise<unknown>): unknown;
+    readContext(_params: import("@my-react/react").ContextObjectType<{
+        $$typeof: symbol;
+        value: unknown;
+        Context: {
+            $$typeof: symbol;
+            displayName: string;
+        };
+    }, {
+        $$typeof: symbol;
+        Context: {
+            $$typeof: symbol;
+            displayName: string;
+        };
+    }>): unknown;
+    runtimeMap: {
+        effectMap: WeakMap<MyReactFiberNode, ListTree<() => void>>;
+        layoutEffectMap: WeakMap<MyReactFiberNode, ListTree<() => void>>;
+        insertionEffectMap: WeakMap<MyReactFiberNode, ListTree<() => void>>;
+        unmountMap: WeakMap<MyReactFiberNode, ListTree<MyReactFiberNode>>;
+        eventMap: WeakMap<MyReactFiberNode, Record<string, ((...args: any[]) => void) & {
+            cb?: any;
+        }>>;
+        triggerCallbackMap: WeakMap<MyReactFiberNode, ListTree<() => void>>;
+    };
+    runtimeFiber: Record<"scheduledFiber" | "errorCatchFiber" | "nextWorkingFiber" | "retriggerFiber" | "visibleFiber", MyReactFiberNode>;
+    dispatcher: {
+        current: {
+            proxy: {
+                readContext: <T_1 = any>(Context: import("@my-react/react").ContextObjectType<{
+                    $$typeof: symbol;
+                    value: T_1;
+                    Context: {
+                        $$typeof: symbol;
+                        displayName: string;
+                    };
+                }, {
+                    $$typeof: symbol;
+                    Context: {
+                        $$typeof: symbol;
+                        displayName: string;
+                    };
+                }> | Promise<T_1>) => T_1;
+                use: <T_1_1 = any>(Context: import("@my-react/react").ContextObjectType<{
+                    $$typeof: symbol;
+                    value: T_1_1;
+                    Context: {
+                        $$typeof: symbol;
+                        displayName: string;
+                    };
+                }, {
+                    $$typeof: symbol;
+                    Context: {
+                        $$typeof: symbol;
+                        displayName: string;
+                    };
+                }> | Promise<T_1_1>) => T_1_1;
+                useCallback: <T_2 extends (...args: any) => any = (...args: any) => any>(callback: T_2, deps?: any[]) => T_2;
+                useContext: <T_3 = any>(Context: import("@my-react/react").ContextObjectType<{
+                    $$typeof: symbol;
+                    value: T_3;
+                    Context: {
+                        $$typeof: symbol;
+                        displayName: string;
+                    };
+                }, {
+                    $$typeof: symbol;
+                    Context: {
+                        $$typeof: symbol;
+                        displayName: string;
+                    };
+                }>) => T_3;
+                useDebugValue: (...args: any[]) => unknown;
+                useDeferredValue: <T_4 = any>(value: T_4) => T_4;
+                useEffect: (action: () => any, deps?: any[]) => void;
+                useId: () => string;
+                useImperativeHandle: (ref: any, createHandle: import("@my-react/react").Reducer, deps: any[]) => unknown;
+                useInsertionEffect: (action: () => any, deps: any[]) => unknown;
+                useLayoutEffect: (action: () => any, deps?: any[]) => void;
+                useMemo: <T_5 = any>(action: () => T_5, deps?: any[]) => T_5;
+                useReducer: (reducer: import("@my-react/react").Reducer, initialArgs: any, init?: (...args: any) => any) => unknown;
+                useRef: <T_6 = any>(value: T_6) => {
+                    current: T_6;
+                };
+                useState: <T_7 = any>(initial: T_7 | (() => T_7)) => [T_7, (t?: T_7 | ((t: T_7) => T_7)) => void];
+                useSignal: <T_8 = any>(initial: T_8 | (() => T_8)) => unknown;
+                useSyncExternalStore: (subscribe: () => any, getSnapshot: () => any, getServerSnapshot?: () => any) => unknown;
+                useTransition: () => [boolean, (cb: () => void) => void];
+            };
+            readContext: <T_1_2 = any>(Context: import("@my-react/react").ContextObjectType<{
+                $$typeof: symbol;
+                value: T_1_2;
+                Context: {
+                    $$typeof: symbol;
+                    displayName: string;
+                };
+            }, {
+                $$typeof: symbol;
+                Context: {
+                    $$typeof: symbol;
+                    displayName: string;
+                };
+            }> | Promise<T_1_2>) => T_1_2;
+            use: <T_1_3 = any>(Context: import("@my-react/react").ContextObjectType<{
+                $$typeof: symbol;
+                value: T_1_3;
+                Context: {
+                    $$typeof: symbol;
+                    displayName: string;
+                };
+            }, {
+                $$typeof: symbol;
+                Context: {
+                    $$typeof: symbol;
+                    displayName: string;
+                };
+            }> | Promise<T_1_3>) => T_1_3;
+            useCallback: <T_2_1 extends (...args: any) => any = (...args: any) => any>(callback: T_2_1, deps?: any[]) => T_2_1;
+            useContext: <T_3_1 = any>(Context: import("@my-react/react").ContextObjectType<{
+                $$typeof: symbol;
+                value: T_3_1;
+                Context: {
+                    $$typeof: symbol;
+                    displayName: string;
+                };
+            }, {
+                $$typeof: symbol;
+                Context: {
+                    $$typeof: symbol;
+                    displayName: string;
+                };
+            }>) => T_3_1;
+            useDebugValue: (...args: any[]) => unknown;
+            useDeferredValue: <T_4_1 = any>(value: T_4_1) => T_4_1;
+            useEffect: (action: () => any, deps?: any[]) => void;
+            useId: () => string;
+            useImperativeHandle: (ref: any, createHandle: import("@my-react/react").Reducer, deps: any[]) => unknown;
+            useInsertionEffect: (action: () => any, deps: any[]) => unknown;
+            useLayoutEffect: (action: () => any, deps?: any[]) => void;
+            useMemo: <T_5_1 = any>(action: () => T_5_1, deps?: any[]) => T_5_1;
+            useReducer: (reducer: import("@my-react/react").Reducer, initialArgs: any, init?: (...args: any) => any) => unknown;
+            useRef: <T_6_1 = any>(value: T_6_1) => {
+                current: T_6_1;
+            };
+            useState: <T_7_1 = any>(initial: T_7_1 | (() => T_7_1)) => [T_7_1, (t?: T_7_1 | ((t: T_7_1) => T_7_1)) => void];
+            useSignal: <T_8_1 = any>(initial: T_8_1 | (() => T_8_1)) => unknown;
+            useSyncExternalStore: (subscribe: () => any, getSnapshot: () => any, getServerSnapshot?: () => any) => unknown;
+            useTransition: () => [boolean, (cb: () => void) => void];
+        };
+    };
+    rootElement: MyReactElementNode;
+    trigger(_fiber: MyReactFiberNode, _state?: import("@my-react/react-shared").STATE_TYPE, cb?: () => void): void;
+    onFiberInitial(cb: (_fiber: MyReactFiberNode) => void): () => boolean;
+    onceFiberInitial(cb: (_fiber: MyReactFiberNode) => void): void;
+    onFiberUpdate(cb: (_fiber: MyReactFiberNode) => void): () => boolean;
+    onFiberChange(cb: (_list: ListTree<MyReactFiberNode>) => void): () => boolean;
+    onceFiberChange(cb: (_list: ListTree<MyReactFiberNode>) => void): void;
+    onceFiberUpdate(cb: (_fiber: MyReactFiberNode) => void): void;
+    onFiberUnmount(cb: (_fiber: MyReactFiberNode) => void): () => boolean;
+    onceFiberUnmount(cb: (_fiber: MyReactFiberNode) => void): void;
+    onFiberState(cb: (_fiber: MyReactFiberNode, _updater: UpdateQueue) => void): () => boolean;
+    onceFiberState(cb: (_fiber: MyReactFiberNode, _updater: UpdateQueue) => void): void;
+    onFiberTrigger(cb: (_fiber: MyReactFiberNode, _state: import("@my-react/react-reconciler").UpdateState) => void): () => boolean;
+    onceFiberTrigger(cb: (_fiber: MyReactFiberNode, _state: import("@my-react/react-reconciler").UpdateState) => void): void;
+    onFiberHMR(cb: (_fiber: MyReactFiberNode, _forceRefresh?: boolean) => void): () => boolean;
+    onceFiberHMR(cb: (_fiber: MyReactFiberNode, _forceRefresh?: boolean) => void): void;
+    onFiberWarn(cb: (_fiber: MyReactFiberNode, ...args: any) => void): () => boolean;
+    onceFiberWarn(cb: (_fiber: MyReactFiberNode, ...args: any) => void): void;
+    onFiberError(cb: (_fiber: MyReactFiberNode, ...args: any) => void): () => boolean;
+    onceFiberError(cb: (_fiber: MyReactFiberNode, ...args: any) => void): void;
+    onPerformanceWarn(cb: (_fiber: MyReactFiberNode) => void): () => boolean;
+    oncePerformanceWarn(cb: (_fiber: MyReactFiberNode) => void): void;
+    onBeforeFiberRun(cb: (_fiber: MyReactFiberNode) => void): () => boolean;
+    onceBeforeFiberRun(cb: (_fiber: MyReactFiberNode) => void): void;
+    onAfterFiberRun(cb: (_fiber: MyReactFiberNode) => void): () => boolean;
+    onceAfterFiberRun(cb: (_fiber: MyReactFiberNode) => void): void;
+    onInstanceInitial(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode) => void): () => boolean;
+    onceInstanceInitial(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode) => void): void;
+    onInstanceUpdate(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode) => void): () => boolean;
+    onceInstanceUpdate(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode) => void): void;
+    onInstanceState(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode, _updater: UpdateQueue) => void): () => boolean;
+    onceInstanceState(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode, _updater: UpdateQueue) => void): void;
+    onInstanceUnmount(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode) => void): () => boolean;
+    onceInstanceUnmount(cb: (_instance: import("@my-react/react").MyReactComponent<any, any, any>, _fiber: MyReactFiberNode) => void): void;
+    onHookInitial(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode) => void): () => boolean;
+    onceHookInitial(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode) => void): void;
+    onHookUpdate(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode) => void): () => boolean;
+    onceHookUpdate(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode) => void): void;
+    onHookUnmount(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode) => void): () => boolean;
+    onceHookUnmount(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode) => void): void;
+    onHookState(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode, _fiber: MyReactFiberNode, _updater: UpdateQueue) => void): () => boolean;
+    onceHookTrigger(cb: (_hook: import("@my-react/react-reconciler").MyReactHookNode, _fiber: MyReactFiberNode, _updater: UpdateQueue) => void): void;
+    onBeforeCommit(cb: () => void): () => boolean;
+    onceBeforeCommit(cb: () => void): void;
+    onAfterCommit(cb: () => void): () => boolean;
+    onceAfterCommit(cb: () => void): void;
+    onBeforeUpdate(cb: () => void): () => boolean;
+    onceBeforeUpdate(cb: () => void): void;
+    onAfterUpdate(cb: () => void): () => boolean;
+    onceAfterUpdate(cb: () => void): void;
+    onBeforeUnmount(cb: () => void): () => boolean;
+    onceBeforeUnmount(cb: () => void): void;
+    onAfterUnmount(cb: () => void): () => boolean;
+    onceAfterUnmount(cb: () => void): void;
+    readonly isMyReactInstance: boolean;
+    _reactInternals: import("@my-react/react").RenderFiber;
+};
+export type ReconcilerDispatch = ReturnType<typeof createDispatch>;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/types/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/dispatch.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,SAAS,EAcV,MAAM,4BAA4B,CAAC;AAOpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAO,MAAM,4BAA4B,CAAC;AAC1F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAgBvD,eAAO,MAAM,cAAc,aAAc,GAAG,aAAa,gBAAgB,eAAe,kBAAkB,UAAU,GAAG;;;;;;;;0BAa7F,gBAAgB,GAAG,IAAI;yBAIxB,gBAAgB,GAAG,IAAI;yBAIvB,gBAAgB,GAAG,IAAI;yBAIvB,gBAAgB,GAAG,IAAI;2BAIrB,gBAAgB,GAAG,IAAI;yBAIzB,gBAAgB,GAAG,IAAI;2BAIrB,gBAAgB,GAAG,IAAI;wBAI1B,gBAAgB,GAAG,IAAI;4BAInB,gBAAgB,GAAG,IAAI;2BA0BxB,SAAS,gBAAgB,CAAC,GAAG,IAAI;gCAQ5B,gBAAgB,GAAG,IAAI;gCAIvB,gBAAgB,GAAG,IAAI;2BAI5B,WAAW,GAAG,IAAI;0BAInB,gBAAgB,GAAG,OAAO;6BAIvB;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,OAAO,CAAC,EAAE,QAAQ,OAAO,CAAC,CAAA;KAAE,GAAG,kBAAkB;2BAI/E;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC1F,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/types/dispatchFiber.d.ts

@@ -0,0 +1,4 @@
+import type { ReconcilerDispatch } from "./dispatch";
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+export declare const ReconcilerDispatchFiber: (renderDispatch: ReconcilerDispatch, fiber: MyReactFiberNode) => void;
+//# sourceMappingURL=dispatchFiber.d.ts.map

package/dist/types/dispatchFiber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchFiber.d.ts","sourceRoot":"","sources":["../../src/dispatchFiber.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,eAAO,MAAM,uBAAuB,mBAAoB,kBAAkB,SAAS,gBAAgB,SAmBlG,CAAC"}

package/dist/types/dispatchMap.d.ts

@@ -0,0 +1,8 @@
+import type { ReconcilerDispatch } from "./dispatch";
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+export declare const initialMap: (dispatch: ReconcilerDispatch, fiber: MyReactFiberNode, config: any) => void;
+export declare const unmountMap: (dispatch: ReconcilerDispatch, fiber: MyReactFiberNode) => void;
+export declare const getFiberWithNativeNode: (fiber: MyReactFiberNode | null, transform: (f: MyReactFiberNode) => MyReactFiberNode | null) => MyReactFiberNode | null;
+export declare const getValidParentFiberWithNode: (_dispatch: ReconcilerDispatch, _fiber: MyReactFiberNode) => MyReactFiberNode;
+export declare const getInsertBeforeNodeFromSiblingAndParent: (fiber: MyReactFiberNode | null, parentFiber: MyReactFiberNode | null) => MyReactFiberNode | null;
+//# sourceMappingURL=dispatchMap.d.ts.map

package/dist/types/dispatchMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchMap.d.ts","sourceRoot":"","sources":["../../src/dispatchMap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAA2C,MAAM,4BAA4B,CAAC;AAE5G,eAAO,MAAM,UAAU,aAAc,kBAAkB,SAAS,gBAAgB,UAAU,GAAG,SAkC5F,CAAC;AAEF,eAAO,MAAM,UAAU,aAAc,kBAAkB,SAAS,gBAAgB,SAI/E,CAAC;AAEF,eAAO,MAAM,sBAAsB,UAC1B,gBAAgB,GAAG,IAAI,iBACf,gBAAgB,KAAK,gBAAgB,GAAG,IAAI,KAC1D,gBAAgB,GAAG,IAYrB,CAAC;AAEF,eAAO,MAAM,2BAA2B,cAAe,kBAAkB,UAAU,gBAAgB,qBAUlG,CAAC;AA4BF,eAAO,MAAM,uCAAuC,UAAW,gBAAgB,GAAG,IAAI,eAAe,gBAAgB,GAAG,IAAI,KAAG,gBAAgB,GAAG,IAUjJ,CAAC"}

package/dist/types/dispatchMount.d.ts

@@ -0,0 +1,4 @@
+import type { ReconcilerDispatch } from "./dispatch";
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+export declare const ReconcilerDispatchMount: (_dispatch: ReconcilerDispatch, _fiber: MyReactFiberNode, config: any) => void;
+//# sourceMappingURL=dispatchMount.d.ts.map

package/dist/types/dispatchMount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchMount.d.ts","sourceRoot":"","sources":["../../src/dispatchMount.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAMnE,eAAO,MAAM,uBAAuB,cAAe,kBAAkB,UAAU,gBAAgB,UAAU,GAAG,SAwF3G,CAAC"}

package/dist/types/feature.d.ts

@@ -0,0 +1,17 @@
+import { type MyReactElementNode } from "@my-react/react";
+import { MyReactFiberNode } from "@my-react/react-reconciler";
+import type { ReconcilerDispatch } from "./dispatch";
+export type RenderContainer = Record<string, any> & {
+    __fiber__: MyReactFiberNode;
+    __container__: ReconcilerDispatch;
+};
+export declare const Reconciler: (_config: any) => {
+    createPortal: (_element: MyReactElementNode, _container: RenderContainer) => import("@my-react/react").MyReactElement;
+    createContainer: (_container: RenderContainer) => RenderContainer;
+    updateContainer: (_element: MyReactElementNode, _container: RenderContainer, _ignore: any, _cb: () => void) => void;
+    injectIntoDevTools: (_config: any) => Promise<void>;
+    injectIntoDevToolsWithSocketIO: (url: string, _config: any) => Promise<void>;
+    flushSync: <T extends any[] = any[], K = any>(action: (...args: T) => K, ...args: T) => K;
+    batchedUpdates: <T extends any[] = any[], K = any>(action: (...args: T) => K, ...args: T) => K;
+};
+//# sourceMappingURL=feature.d.ts.map

package/dist/types/feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../src/feature.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACtG,OAAO,EACL,gBAAgB,EASjB,MAAM,4BAA4B,CAAC;AAUpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAOrD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAClD,SAAS,EAAE,gBAAgB,CAAC;IAC5B,aAAa,EAAE,kBAAkB,CAAC;CACnC,CAAC;AAGF,eAAO,MAAM,UAAU,YAAa,GAAG;;kCAKA,eAAe;gCAYjB,kBAAkB,cAAc,eAAe,WAAW,GAAG,OAAO,MAAM,IAAI;kCA6DtE,GAAG;0CAaK,MAAM,WAAW,GAAG;;;CAsBxE,CAAC"}

package/dist/types/hmr.d.ts

@@ -0,0 +1,3 @@
+import type { ReconcilerDispatch } from "./dispatch";
+export declare const autoSetDevHMR: (dispatch: ReconcilerDispatch) => void;
+//# sourceMappingURL=hmr.d.ts.map

package/dist/types/hmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.d.ts","sourceRoot":"","sources":["../../src/hmr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAOrD,eAAO,MAAM,aAAa,aAAc,kBAAkB,SAYzD,CAAC"}

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+import type { MyReactFiberNode } from "@my-react/react-reconciler";
+import type createReconcilerType from "react-reconciler";
+export * from "@my-react/react-reconciler";
+export declare const version: string;
+export declare const createReconciler: typeof createReconcilerType;
+export interface FiberNode<T = Record<string, any>> extends MyReactFiberNode {
+    stateNode: T;
+    return: FiberNode | null;
+    child: FiberNode | null;
+    sibling: FiberNode | null;
+    alternate?: FiberNode | null;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,oBAAoB,MAAM,kBAAkB,CAAC;AAEzD,cAAc,4BAA4B,CAAC;AAE3C,eAAO,MAAM,OAAO,QAAc,CAAC;AAEnC,eAAO,MAAM,gBAAgB,6BAAuD,CAAC;AAErF,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAE,SAAQ,gBAAgB;IAC1E,SAAS,EAAE,CAAC,CAAC;IACb,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CAC9B"}

package/dist/types/polyfill.d.ts

@@ -0,0 +1,2 @@
+export declare const loadScript: (url: string) => Promise<void>;
+//# sourceMappingURL=polyfill.d.ts.map

package/dist/types/polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../src/polyfill.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,QAAS,MAAM,kBAmDrC,CAAC"}

package/dist/types/portal.d.ts

@@ -0,0 +1,6 @@
+import { type MyReactElementNode } from "@my-react/react";
+import type { RenderContainer } from "./feature";
+import type { MyReactFiberNode, CustomRenderDispatch } from "@my-react/react-reconciler";
+export declare const createPortal: (_element: MyReactElementNode, _container: RenderContainer) => import("@my-react/react").MyReactElement;
+export declare const nextWorkPortal: (renderDispatch: CustomRenderDispatch, fiber: MyReactFiberNode) => void;
+//# sourceMappingURL=portal.d.ts.map

package/dist/types/portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../../src/portal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAiB,MAAM,iBAAiB,CAAC;AAIzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAyB,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEhH,eAAO,MAAM,YAAY,aAAc,kBAAkB,cAAc,eAAe,6CAIrF,CAAC;AAEF,eAAO,MAAM,cAAc,mBAAoB,oBAAoB,SAAS,gBAAgB,SAgB3F,CAAC"}

package/dist/types/scheduler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ */
+export declare const prepareScheduler: () => void;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/types/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/scheduler.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,eAAO,MAAM,gBAAgB,YAU5B,CAAC"}

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./dist/types";

package/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const React = require("react");
+
+if (!React.isMyReact) {
+  throw new Error(
+    "@my-react/react-reconciler-compact requires 'React' to be set as '@my-react/react'. Please ensure you have set the alias correctly in your bundler configuration."
+  );
+}
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./dist/cjs/index.production");
+} else {
+  module.exports = require("./dist/cjs/index.development");
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@my-react/react-reconciler-compact",
+  "description": "@my-react/react-reconciler-compact",
+  "author": "MrWangJustToDo",
+  "license": "MIT",
+  "version": "0.0.1",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "dist",
+    "index.js",
+    "index.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MrWangJustToDo/MyReact",
+    "directory": "packages/myreact-reconciler-compact"
+  },
+  "homepage": "https://mrwangjusttodo.github.io/MyReact",
+  "exports": {
+    ".": {
+      "default": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "buildOptions": [
+    {
+      "input": "./src/index.ts",
+      "output": [
+        {
+          "dir": "./dist",
+          "entryFileNames": "cjs/index.js",
+          "format": "cjs",
+          "type": true,
+          "multiple": true
+        }
+      ]
+    }
+  ],
+  "devDependencies": {
+    "@my-react/react-reconciler": "^0.3.10",
+    "@my-react/react-shared": "^0.3.10",
+    "@types/react-reconciler": "^0.31.0"
+  },
+  "peerDependencies": {
+    "@my-react/react": ">=0.3.10"
+  }
+}