@tarojs/runtime 3.5.0-canary.0 → 3.5.0-canary.1

package/dist/dom/event-source.d.ts

@@ -1,2 +1,7 @@
 import type { TaroNode } from './node';
-export declare const eventSource: Map<string | null | undefined, TaroNode>;
+interface IEventSource extends Map<string | undefined | null, TaroNode> {
+    removeNode(child: TaroNode): void;
+    removeNodeTree(child: TaroNode): void;
+}
+export declare const eventSource: IEventSource;
+export {};

package/dist/dom/node.d.ts

@@ -4,8 +4,13 @@ import type { UpdatePayload } from '../interface';
 import type { TaroDocument } from './document';
 import type { TaroRootElement } from './root';
 import type { TaroElement } from './element';
+interface RemoveChildOptions {
+    cleanRef?: boolean;
+    doUpdate?: boolean;
+}
 export declare class TaroNode extends TaroEventTarget {
     uid: string;
+    sid: string;
     nodeType: NodeType;
     nodeName: string;
     parentNode: TaroNode | null;
@@ -17,6 +22,7 @@ export declare class TaroNode extends TaroEventTarget {
      * like jQuery's $.empty()
      */
     private _empty;
+    private updateChildNodes;
     protected get _root(): TaroRootElement | null;
     protected findIndex(refChild: TaroNode): number;
     get _path(): string;
@@ -30,12 +36,44 @@ export declare class TaroNode extends TaroEventTarget {
      * @TODO 等待完整 innerHTML 实现
      */
     set textContent(text: string);
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/insertBefore
+     * @scenario
+     * [A,B,C]
+     *   1. insert D before C, D has no parent
+     *   2. insert D before C, D has the same parent of C
+     *   3. insert D before C, D has the different parent of C
+     */
     insertBefore<T extends TaroNode>(newChild: T, refChild?: TaroNode | null, isReplace?: boolean): T;
-    appendChild(child: TaroNode): void;
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/appendChild
+     * @scenario
+     * [A,B,C]
+     *   1. append C, C has no parent
+     *   2. append C, C has the same parent of B
+     *   3. append C, C has the different parent of B
+     */
+    appendChild(newChild: TaroNode): TaroNode;
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/replaceChild
+     * @scenario
+     * [A,B,C]
+     *   1. replace B with C, C has no parent
+     *   2. replace B with C, C has no parent, C has the same parent of B
+     *   3. replace B with C, C has no parent, C has the different parent of B
+     */
     replaceChild(newChild: TaroNode, oldChild: TaroNode): TaroNode | undefined;
-    removeChild<T extends TaroNode>(child: T, isReplace?: boolean): T;
-    remove(isReplace?: boolean): void;
+    /**
+     * @doc https://developer.mozilla.org/zh-CN/docs/Web/API/Node/removeChild
+     * @scenario
+     * [A,B,C]
+     *   1. remove A or B
+     *   2. remove C
+     */
+    removeChild<T extends TaroNode>(child: T, options?: RemoveChildOptions): T;
+    remove(options?: RemoveChildOptions): void;
     hasChildNodes(): boolean;
     enqueueUpdate(payload: UpdatePayload): void;
     get ownerDocument(): TaroDocument;
 }
+export {};

package/dist/dom-external/mutation-observer/implements.d.ts

@@ -0,0 +1,52 @@
+import type { TaroNode } from '../../dom/node';
+import type { MutationRecord } from './record';
+export declare type MutationCallback = (mutations: MutationRecord[]) => any;
+/**
+ * @see https://dom.spec.whatwg.org/#dictdef-mutationobserverinit
+ */
+export interface MutationObserverInit {
+    attributeFilter?: string[];
+    attributeOldValue?: boolean;
+    attributes?: boolean;
+    characterData?: boolean;
+    characterDataOldValue?: boolean;
+    childList?: boolean;
+    subtree?: boolean;
+}
+/**
+ * The MutationObserver provides the ability
+ * to watch for changes being made to the DOM tree.
+ * It will invoke a specified callback function
+ * when DOM changes occur.
+ * @see https://dom.spec.whatwg.org/#mutationobserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+ */
+export declare class MutationObserverImpl {
+    callback: MutationCallback;
+    target: TaroNode | null;
+    options: MutationObserverInit;
+    records: MutationRecord[];
+    constructor(callback: MutationCallback);
+    /**
+     * Configures the MutationObserver
+     * to begin receiving notifications
+     * through its callback function
+     * when DOM changes matching the given options occur.
+     *
+     * Options matching is to be implemented.
+     */
+    observe(target: TaroNode, options?: MutationObserverInit): void;
+    /**
+     * Stop the MutationObserver instance
+     * from receiving further notifications
+     * until and unless observe() is called again.
+     */
+    disconnect(): void;
+    /**
+     * Removes all pending notifications
+     * from the MutationObserver's notification queue
+     * and returns them in a new Array of MutationRecord objects.
+     */
+    takeRecords(): MutationRecord[];
+}
+export declare function recordMutation(record: MutationRecord): void;

package/dist/dom-external/mutation-observer/index.d.ts

@@ -0,0 +1,12 @@
+import { MutationObserverImpl } from './implements';
+import { MutationRecord } from './record';
+import type { MutationCallback, MutationObserverInit } from './implements';
+import type { TaroNode } from '../../dom/node';
+export declare class MutationObserver {
+    core: Pick<MutationObserverImpl, 'observe' | 'disconnect' | 'takeRecords'>;
+    constructor(callback: MutationCallback);
+    observe(...args: [TaroNode, MutationObserverInit?]): void;
+    disconnect(): void;
+    takeRecords(): MutationRecord[];
+    static record(record: MutationRecord): void;
+}

package/dist/dom-external/mutation-observer/record.d.ts

@@ -0,0 +1,24 @@
+import type { TaroNode } from '../../dom/node';
+/**
+ * A MutationRecord represents an individual DOM mutation.
+ * It is the object that is passed to MutationObserver's callback.
+ * @see https://dom.spec.whatwg.org/#interface-mutationrecord
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord
+*/
+export interface MutationRecord {
+    readonly target: TaroNode;
+    readonly addedNodes?: TaroNode[];
+    readonly removedNodes?: TaroNode[];
+    readonly previousSibling?: TaroNode | null;
+    readonly nextSibling?: TaroNode | null;
+    readonly attributeName?: string | null;
+    readonly attributeNamespace?: string | null;
+    oldValue?: string | null;
+    readonly type: MutationRecordType;
+    readonly value?: string | null;
+}
+export declare const enum MutationRecordType {
+    ATTRIBUTES = "attributes",
+    CHARACTER_DATA = "characterData",
+    CHILD_LIST = "childList"
+}

package/dist/dsl/common.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="react" />
-import { eventHandler } from '../dom/event';
 import type { PageConfig } from '@tarojs/taro';
 import type { Instance, PageInstance, PageProps } from './instance';
 export declare function injectPageInstance(inst: Instance<PageProps>, id: string): void;
@@ -13,24 +12,4 @@ export declare function getOnShowEventKey(path: string): string;
 export declare function getOnHideEventKey(path: string): string;
 export declare function createPageConfig(component: any, pageName?: string, data?: Record<string, unknown>, pageConfig?: PageConfig): PageInstance;
 export declare function createComponentConfig(component: React.ComponentClass, componentName?: string, data?: Record<string, unknown>): any;
-export declare function createRecursiveComponentConfig(componentName?: string): {
-    properties: {
-        i: {
-            type: ObjectConstructor;
-            value: {
-                nn: string;
-            };
-        };
-        l: {
-            type: StringConstructor;
-            value: string;
-        };
-    };
-    options: {
-        addGlobalClass: boolean;
-        virtualHost: boolean;
-    };
-    methods: {
-        eh: typeof eventHandler;
-    };
-};
+export declare function createRecursiveComponentConfig(componentName?: string): any;

package/dist/dsl/instance.d.ts

@@ -21,13 +21,13 @@ interface VueInternal {
 export interface PageProps {
     tid?: string;
 }
-export interface ReactPageComponent<T = PageProps> extends ComponentClass<T>, Show, PageInstance {
+export interface ReactPageComponent<T = PageProps> extends ComponentClass<T>, PageInstance {
 }
-export interface ReactPageInstance<T = PageProps> extends Component<T>, Show, PageInstance {
+export interface ReactPageInstance<T = PageProps> extends Component<T>, PageInstance {
     componentDidShow?(): void;
     componentDidHide?(): void;
 }
-export interface ReactAppInstance<T = AppInstance> extends Component<T>, Show, AppInstance {
+export interface ReactAppInstance<T = AppInstance> extends Component<T>, AppInstance {
 }
 export interface PageLifeCycle extends Show {
     onPullDownRefresh?(): void;
@@ -63,15 +63,17 @@ export interface PageInstance extends PageLifeCycle {
     options?: Record<string, unknown>;
 }
 interface Show {
-    componentDidShow?(options?: unknown): void;
-    componentDidHide?(options?: unknown): void;
-    onShow?(options?: unknown): void;
-    onHide?(options?: unknown): void;
+    componentDidShow?(): void;
+    componentDidHide?(): void;
+    onShow?(): void;
+    onHide?(): void;
 }
 export interface AppInstance extends Show {
-    onLaunch?(options?: string): void;
+    onLaunch?(options?: Record<string, unknown>): void;
     mount?(component: React.ComponentClass | ComponentOptions<VueCtor> | Vue3Component, id: string, cb: (...args: any[]) => void): void;
     mount?(component: React.ComponentClass | ComponentOptions<VueCtor> | Vue3Component, id: string, cb: () => void): void;
+    componentDidShow?(options?: Record<string, unknown>): void;
+    onShow?(options?: Record<string, unknown>): void;
     unmount?(id: string): void;
     unmount?(id: string, cb: () => void): void;
     onPageNotFound?(res: any): void;

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { TaroElement } from './dom/element';
 export { TaroRootElement } from './dom/root';
 export { FormElement } from './dom/form';
 export { SVGElement } from './dom/svg';
+export { MutationObserver } from './dom-external/mutation-observer';
 export { TaroEvent, createEvent, eventHandler } from './dom/event';
 export { createDocument, document } from './bom/document';
 export { window } from './bom/window';
@@ -25,3 +26,4 @@ export { raf as requestAnimationFrame, caf as cancelAnimationFrame, now } from '
 export { getComputedStyle } from './bom/getComputedStyle';
 export * from './interface';
 export { incrementId } from './utils';
+export { eventSource } from './dom/event-source';

package/dist/interface/hydrate.d.ts

@@ -16,7 +16,8 @@ export interface MiniElementData {
     [Shortcuts.NodeName]: string;
     [Shortcuts.Class]?: string;
     [Shortcuts.Style]?: string;
-    uid: string;
+    uid?: string;
+    sid: string;
     [key: string]: unknown;
 }
 interface MiniTextData {