@viewfly/core 0.0.24 → 0.0.26

package/bundles/foundation/_utils.d.ts

@@ -1,3 +1,4 @@
+import { Component, JSXElement, JSXInternal, JSXText, NativeNode, Props } from '@viewfly/core';
 export interface ListenDelegate {
     delegate: () => any;
     listenFn: ((...args: any[]) => any) | void;
@@ -11,3 +12,17 @@ export declare const refKey = "ref";
 export declare function getObjectChanges(newProps: Record<string, any>, oldProps: Record<string, any>): ObjectChanges;
 export declare function classToString(config: unknown): string;
 export declare function styleToObject(style: string | Record<string, any>): Record<string, any>;
+export interface Atom {
+    jsxNode: JSXElement | JSXText | Component;
+    parent: Atom | null;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+}
+export interface ComponentView {
+    atom: Atom;
+    template: JSXInternal.JSXNode;
+    host: NativeNode;
+    isParent: boolean;
+    render(newProps: Props, oldProps: Props): JSXInternal.JSXNode;
+}

package/bundles/foundation/component.d.ts

@@ -1,5 +1,6 @@
 import { AbstractType, InjectFlags, InjectionToken, Injector, Provider, ReflectiveInjector, Type } from '../di/_api';
 import { JSXTypeof, Key, Props } from './jsx-element';
+import { ComponentView } from './_utils';
 import { JSXInternal } from './types';
 export declare class JSXComponent {
     props: Props;
@@ -11,14 +12,16 @@ export declare class JSXComponent {
  * Viewfly 组件管理类，用于管理组件的生命周期，上下文等
  */
 export declare class Component extends ReflectiveInjector implements JSXTypeof {
-    type: JSXInternal.ElementClass;
+    type: JSXInternal.ComponentConstructor;
     props: Props;
     key?: Key | undefined;
-    $$typeOf: JSXInternal.ElementClass<any>;
+    $$typeOf: JSXInternal.ComponentConstructor<any>;
+    $$view: ComponentView;
     destroyCallbacks: LifeCycleCallback[];
     mountCallbacks: LifeCycleCallback[];
     propsChangedCallbacks: PropsChangedCallback<any>[];
     updatedCallbacks: LifeCycleCallback[];
+    changedSubComponents: Set<Component>;
     get dirty(): boolean;
     get changed(): boolean;
     protected _dirty: boolean;
@@ -28,15 +31,15 @@ export declare class Component extends ReflectiveInjector implements JSXTypeof {
     private propsChangedDestroyCallbacks;
     private unWatch?;
     private isFirstRending;
-    constructor(context: Injector, type: JSXInternal.ElementClass, props: Props, key?: Key | undefined);
+    constructor(context: Injector, type: JSXInternal.ComponentConstructor, props: Props, key?: Key | undefined);
     is(target: JSXTypeof): boolean;
     provide<T>(providers: Provider<T> | Provider<T>[]): void;
     setup(): {
-        template: JSXInternal.JSXNode;
-        render: (newProps: Props, oldProps: Props) => JSXInternal.JSXNode;
+        template: any;
+        render: (newProps: Props, oldProps: Props) => any;
     };
     markAsDirtied(): void;
-    markAsChanged(): void;
+    markAsChanged(changedComponent?: Component): void;
     rendered(): void;
     destroy(): void;
     private invokePropsChangedHooks;
@@ -110,13 +113,13 @@ export type ExtractInstanceType<T, U = T extends (...args: any) => any ? ReturnT
 export interface AbstractInstanceType<T extends Record<string, any>> {
     (): T & JSXInternal.ComponentInstance<any>;
 }
-export declare class Ref<T, U> {
+export declare class Ref<T> {
     private callback;
     private unBindMap;
     private targetCaches;
-    constructor(callback: RefListener<U>);
-    bind(value: U): void;
-    unBind(value: U): void;
+    constructor(callback: RefListener<T>);
+    bind(value: T): void;
+    unBind(value: T): void;
 }
 /**
  * 用于节点渲染完成时获取 DOM 节点
@@ -139,7 +142,7 @@ export declare class Ref<T, U> {
  * }
  * ```
  */
-export declare function useRef<T, U = ExtractInstanceType<T>>(callback: RefListener<U>): Ref<T, U>;
+export declare function useRef<T, U = ExtractInstanceType<T>>(callback: RefListener<U>): Ref<U>;
 declare const depsKey: unique symbol;
 /**
  * 组件状态实例，直接调用可以获取最新的状态，通过 set 方法可以更新状态

package/bundles/foundation/jsx-element.d.ts

@@ -6,13 +6,13 @@ export interface Props {
     [key: string]: any;
     [key: symbol]: any;
 }
-export declare function Fragment(props: Props): () => JSXInternal.JSXNode | JSXInternal.JSXNode[];
+export declare function Fragment(props: Props): () => any;
 export type Key = number | string;
 export declare function jsx(name: string, props: Props, key?: Key): JSXElement;
-export declare function jsx(setup: JSXInternal.ElementClass, props: Props, key?: Key): JSXComponent;
+export declare function jsx(setup: JSXInternal.ComponentConstructor, props: Props, key?: Key): JSXComponent;
 export declare const jsxs: typeof jsx;
 export interface JSXTypeof {
-    $$typeOf: string | JSXInternal.ElementClass;
+    $$typeOf: string | JSXInternal.ComponentConstructor;
     is(target: JSXTypeof): boolean;
 }
 export declare class JSXText implements JSXTypeof {

package/bundles/foundation/memo.d.ts

@@ -1,3 +1,3 @@
 import { Props } from './jsx-element';
 import { JSXInternal } from './types';
-export declare function withMemo<T extends Props = Props>(shouldUpdate: JSXInternal.ComponentInstance<T>['$shouldUpdate'], render: () => JSXInternal.Element): JSXInternal.ComponentInstance<T>;
+export declare function withMemo<T extends Props = Props>(shouldUpdate: JSXInternal.ComponentInstance<T>['$shouldUpdate'], render: () => JSXInternal.JSXNode): JSXInternal.ComponentInstance<T>;

package/bundles/foundation/renderer.d.ts

@@ -10,13 +10,10 @@ export declare class Renderer {
     private nativeRenderer;
     private rootComponentRef;
     private hostRef;
-    private componentAtomCaches;
     private isInit;
     constructor(nativeRenderer: NativeRenderer, rootComponentRef: RootComponentRef, hostRef: HostRef);
     render(): void;
-    private reconcile;
-    private getPrevSibling;
-    private reconcileElement;
+    private updateView;
     private applyChanges;
     private diff;
     private reuseComponentView;

package/bundles/foundation/root.component.d.ts

@@ -6,6 +6,6 @@ import { Injector } from '../di/_api';
  */
 export declare class RootComponent extends Component {
     onChange: (() => void) | null;
-    constructor(factory: JSXInternal.ElementClass, parentInjector: Injector);
-    markAsChanged(): void;
+    constructor(factory: JSXInternal.ComponentConstructor, parentInjector: Injector);
+    markAsChanged(changedComponent?: Component): void;
 }

package/bundles/foundation/types.d.ts

@@ -8,22 +8,23 @@ export declare namespace JSXInternal {
         $shouldUpdate?(currentProps: P, prevProps: P): boolean;
     }
     type JSXNode = Element | JSXInternal.ElementClass | string | number | boolean | null | undefined | JSXNode[];
-    interface Element<P = any, C extends string | ElementClass<P> = string | ElementClass<P>> {
-    }
+    type ComponentConstructor<P = any> = (props: P) => (() => Element) | ComponentInstance<P>;
+    type Element<P = any, C extends string | ComponentConstructor<P> = string | ComponentConstructor<P>> = C extends string ? IntrinsicElements[C] : (() => Element) | ComponentInstance<P>;
     interface IntrinsicAttributes {
         key?: Key;
         ref?: any;
     }
     interface RefAttributes<T> extends IntrinsicAttributes {
-        ref?: Ref<T, ExtractInstanceType<T>> | Ref<T, ExtractInstanceType<T>>[];
+        ref?: Ref<ExtractInstanceType<T>> | Ref<ExtractInstanceType<T>>[];
     }
-    interface ElementClass<P = any> {
-        (props?: P): () => (JSXNode | ComponentInstance<P>);
+    interface ElementClass<P = any> extends ComponentInstance<P> {
     }
     interface ElementChildrenAttribute {
     }
     interface IntrinsicElements {
+        [name: string]: any;
     }
-    interface IntrinsicClassAttributes<T> extends RefAttributes<T> {
+    interface IntrinsicClassAttributes<T> {
+        ref?: Ref<T>;
     }
 }

package/bundles/index.esm.js

@@ -660,6 +660,7 @@ class Component extends ReflectiveInjector {
         this.mountCallbacks = [];
         this.propsChangedCallbacks = [];
         this.updatedCallbacks = [];
+        this.changedSubComponents = new Set();
         this._dirty = true;
         this._changed = true;
         this.updatedDestroyCallbacks = [];
@@ -755,14 +756,18 @@ class Component extends ReflectiveInjector {
         this._dirty = true;
         this.markAsChanged();
     }
-    markAsChanged() {
+    markAsChanged(changedComponent) {
+        if (changedComponent) {
+            this.changedSubComponents.add(changedComponent);
+        }
         if (this._changed) {
             return;
         }
         this._changed = true;
-        this.parentComponent.markAsChanged();
+        this.parentComponent.markAsChanged(this);
     }
     rendered() {
+        this.changedSubComponents.clear();
         const is = this.isFirstRending;
         this.isFirstRending = false;
         this._dirty = this._changed = false;
@@ -1163,9 +1168,12 @@ class RootComponent extends Component {
         super(parentInjector, factory, {});
         this.onChange = null;
     }
-    markAsChanged() {
+    markAsChanged(changedComponent) {
         var _a;
         this._changed = true;
+        if (changedComponent) {
+            this.changedSubComponents.add(changedComponent);
+        }
         (_a = this.onChange) === null || _a === void 0 ? void 0 : _a.call(this);
     }
 }
@@ -1210,103 +1218,48 @@ class RootComponentRef {
 }
 class HostRef {
 }
-class Atom {
-    constructor(jsxNode, parent) {
-        this.jsxNode = jsxNode;
-        this.parent = parent;
-        this.nativeNode = null;
-        this.child = null;
-        this.sibling = null;
-    }
-}
 let Renderer = class Renderer {
     constructor(nativeRenderer, rootComponentRef, hostRef) {
         this.nativeRenderer = nativeRenderer;
         this.rootComponentRef = rootComponentRef;
         this.hostRef = hostRef;
-        this.componentAtomCaches = new WeakMap();
         this.isInit = true;
     }
     render() {
         const component = this.rootComponentRef.component;
         const host = this.hostRef.host;
         if (this.isInit) {
-            const atom = new Atom(component, null);
+            const atom = {
+                jsxNode: component,
+                parent: null,
+                sibling: null,
+                child: null,
+                nativeNode: null
+            };
             this.buildView(atom, {
                 isParent: true,
                 host
             });
         }
         else {
-            this.reconcile(component, {
-                host,
-                isParent: true
-            });
+            this.updateView(component);
         }
         this.isInit = false;
     }
-    reconcile(component, context) {
+    updateView(component) {
         if (component.dirty) {
-            this.applyChanges(component, context);
+            this.applyChanges(component);
             component.rendered();
         }
         else if (component.changed) {
-            const atom = this.componentAtomCaches.get(component).atom.child;
-            this.reconcileElement(atom, context);
+            component.changedSubComponents.forEach(child => {
+                this.updateView(child);
+            });
             component.rendered();
         }
-        else {
-            const prevSibling = this.getPrevSibling(component);
-            if (prevSibling) {
-                context.isParent = false;
-                context.host = prevSibling;
-            }
-        }
-    }
-    getPrevSibling(component) {
-        let atom = this.componentAtomCaches.get(component).atom.child;
-        const childAtoms = [];
-        while (atom) {
-            childAtoms.push(atom);
-            atom = atom.sibling;
-        }
-        const components = [];
-        while (childAtoms.length) {
-            const last = childAtoms.pop();
-            if (last.jsxNode instanceof Component) {
-                components.push(last.jsxNode);
-                continue;
-            }
-            return last.nativeNode;
-        }
-        for (const component of components) {
-            const nativeNode = this.getPrevSibling(component);
-            if (nativeNode) {
-                return nativeNode;
-            }
-        }
-        return null;
     }
-    reconcileElement(atom, context) {
-        while (atom) {
-            if (atom.jsxNode instanceof Component) {
-                this.reconcile(atom.jsxNode, context);
-                atom = atom.sibling;
-                continue;
-            }
-            if (atom.jsxNode instanceof JSXElement) {
-                this.reconcileElement(atom.child, {
-                    host: atom.nativeNode,
-                    isParent: true
-                });
-                context.host = atom.nativeNode;
-                context.isParent = false;
-            }
-            atom = atom.sibling;
-        }
-    }
-    applyChanges(component, context) {
-        const { atom, render } = this.componentAtomCaches.get(component);
+    applyChanges(component) {
+        const { atom, render, host, isParent } = component.$$view;
         const diffAtom = atom.child;
         const template = render(component.props, component.props);
         if (template) {
@@ -1315,7 +1268,10 @@ let Renderer = class Renderer {
         else {
             atom.child = null;
         }
-        this.diff(atom.child, diffAtom, context, 0, 0);
+        this.diff(atom.child, diffAtom, {
+            host,
+            isParent
+        }, 0, 0);
     }
     diff(newAtom, oldAtom, context, expectIndex, index) {
         const oldChildren = [];
@@ -1331,16 +1287,12 @@ let Renderer = class Renderer {
         const changeCommits = {
             updateComponent: (newAtom, reusedAtom, expectIndex, diffIndex) => {
                 commits.push((offset) => {
-                    const { render, template } = this.componentAtomCaches.get(reusedAtom.jsxNode);
+                    const { render, template } = reusedAtom.jsxNode.$$view;
                     const newProps = newAtom.jsxNode.props;
                     const oldProps = reusedAtom.jsxNode.props;
                     newAtom.jsxNode = reusedAtom.jsxNode;
                     const newTemplate = render(newProps, oldProps);
-                    this.componentAtomCaches.set(newAtom.jsxNode, {
-                        render,
-                        template: newTemplate,
-                        atom: newAtom
-                    });
+                    newAtom.jsxNode.$$view = Object.assign({ render, template: newTemplate, atom: newAtom }, context);
                     if (newTemplate === template) {
                         this.reuseComponentView(newAtom, reusedAtom, context, expectIndex !== diffIndex - offset);
                         return;
@@ -1516,7 +1468,7 @@ let Renderer = class Renderer {
     }
     buildView(atom, context) {
         if (atom.jsxNode instanceof Component) {
-            this.componentRender(atom.jsxNode, atom);
+            this.componentRender(atom.jsxNode, atom, context);
             let child = atom.child;
             while (child) {
                 this.buildView(child, context);
@@ -1560,24 +1512,33 @@ let Renderer = class Renderer {
             }
         }
     }
-    componentRender(component, from) {
+    componentRender(component, from, context) {
         const { template, render } = component.setup();
         if (template) {
             this.linkTemplate(template, component, from);
         }
-        this.componentAtomCaches.set(component, {
-            render,
-            template,
-            atom: from
-        });
+        component.$$view = Object.assign({ render,
+            template, atom: from }, context);
         return from;
     }
     createChainByComponentFactory(context, factory, parent) {
         const component = factory.createInstance(context);
-        return new Atom(component, parent);
+        return {
+            jsxNode: component,
+            parent,
+            sibling: null,
+            child: null,
+            nativeNode: null
+        };
     }
     createChainByJSXElement(context, element, parent) {
-        const atom = new Atom(element, parent);
+        const atom = {
+            jsxNode: element,
+            parent,
+            sibling: null,
+            child: null,
+            nativeNode: null
+        };
         if (Reflect.has(element.props, 'children')) {
             const jsxChildren = element.props.children;
             const children = this.createChainByChildren(context, Array.isArray(jsxChildren) ? jsxChildren : [jsxChildren], atom, []);
@@ -1586,7 +1547,13 @@ let Renderer = class Renderer {
         return atom;
     }
     createChainByJSXText(node, parent) {
-        return new Atom(node, parent);
+        return {
+            jsxNode: node,
+            parent,
+            sibling: null,
+            child: null,
+            nativeNode: null
+        };
     }
     createChainByChildren(context, children, parent, atoms) {
         for (const item of children) {

package/bundles/index.js

@@ -662,6 +662,7 @@ class Component extends ReflectiveInjector {
         this.mountCallbacks = [];
         this.propsChangedCallbacks = [];
         this.updatedCallbacks = [];
+        this.changedSubComponents = new Set();
         this._dirty = true;
         this._changed = true;
         this.updatedDestroyCallbacks = [];
@@ -757,14 +758,18 @@ class Component extends ReflectiveInjector {
         this._dirty = true;
         this.markAsChanged();
     }
-    markAsChanged() {
+    markAsChanged(changedComponent) {
+        if (changedComponent) {
+            this.changedSubComponents.add(changedComponent);
+        }
         if (this._changed) {
             return;
         }
         this._changed = true;
-        this.parentComponent.markAsChanged();
+        this.parentComponent.markAsChanged(this);
     }
     rendered() {
+        this.changedSubComponents.clear();
         const is = this.isFirstRending;
         this.isFirstRending = false;
         this._dirty = this._changed = false;
@@ -1165,9 +1170,12 @@ class RootComponent extends Component {
         super(parentInjector, factory, {});
         this.onChange = null;
     }
-    markAsChanged() {
+    markAsChanged(changedComponent) {
         var _a;
         this._changed = true;
+        if (changedComponent) {
+            this.changedSubComponents.add(changedComponent);
+        }
         (_a = this.onChange) === null || _a === void 0 ? void 0 : _a.call(this);
     }
 }
@@ -1212,103 +1220,48 @@ class RootComponentRef {
 }
 class HostRef {
 }
-class Atom {
-    constructor(jsxNode, parent) {
-        this.jsxNode = jsxNode;
-        this.parent = parent;
-        this.nativeNode = null;
-        this.child = null;
-        this.sibling = null;
-    }
-}
 exports.Renderer = class Renderer {
     constructor(nativeRenderer, rootComponentRef, hostRef) {
         this.nativeRenderer = nativeRenderer;
         this.rootComponentRef = rootComponentRef;
         this.hostRef = hostRef;
-        this.componentAtomCaches = new WeakMap();
         this.isInit = true;
     }
     render() {
         const component = this.rootComponentRef.component;
         const host = this.hostRef.host;
         if (this.isInit) {
-            const atom = new Atom(component, null);
+            const atom = {
+                jsxNode: component,
+                parent: null,
+                sibling: null,
+                child: null,
+                nativeNode: null
+            };
             this.buildView(atom, {
                 isParent: true,
                 host
             });
         }
         else {
-            this.reconcile(component, {
-                host,
-                isParent: true
-            });
+            this.updateView(component);
         }
         this.isInit = false;
     }
-    reconcile(component, context) {
+    updateView(component) {
         if (component.dirty) {
-            this.applyChanges(component, context);
+            this.applyChanges(component);
             component.rendered();
         }
         else if (component.changed) {
-            const atom = this.componentAtomCaches.get(component).atom.child;
-            this.reconcileElement(atom, context);
+            component.changedSubComponents.forEach(child => {
+                this.updateView(child);
+            });
             component.rendered();
         }
-        else {
-            const prevSibling = this.getPrevSibling(component);
-            if (prevSibling) {
-                context.isParent = false;
-                context.host = prevSibling;
-            }
-        }
-    }
-    getPrevSibling(component) {
-        let atom = this.componentAtomCaches.get(component).atom.child;
-        const childAtoms = [];
-        while (atom) {
-            childAtoms.push(atom);
-            atom = atom.sibling;
-        }
-        const components = [];
-        while (childAtoms.length) {
-            const last = childAtoms.pop();
-            if (last.jsxNode instanceof Component) {
-                components.push(last.jsxNode);
-                continue;
-            }
-            return last.nativeNode;
-        }
-        for (const component of components) {
-            const nativeNode = this.getPrevSibling(component);
-            if (nativeNode) {
-                return nativeNode;
-            }
-        }
-        return null;
     }
-    reconcileElement(atom, context) {
-        while (atom) {
-            if (atom.jsxNode instanceof Component) {
-                this.reconcile(atom.jsxNode, context);
-                atom = atom.sibling;
-                continue;
-            }
-            if (atom.jsxNode instanceof JSXElement) {
-                this.reconcileElement(atom.child, {
-                    host: atom.nativeNode,
-                    isParent: true
-                });
-                context.host = atom.nativeNode;
-                context.isParent = false;
-            }
-            atom = atom.sibling;
-        }
-    }
-    applyChanges(component, context) {
-        const { atom, render } = this.componentAtomCaches.get(component);
+    applyChanges(component) {
+        const { atom, render, host, isParent } = component.$$view;
         const diffAtom = atom.child;
         const template = render(component.props, component.props);
         if (template) {
@@ -1317,7 +1270,10 @@ exports.Renderer = class Renderer {
         else {
             atom.child = null;
         }
-        this.diff(atom.child, diffAtom, context, 0, 0);
+        this.diff(atom.child, diffAtom, {
+            host,
+            isParent
+        }, 0, 0);
     }
     diff(newAtom, oldAtom, context, expectIndex, index) {
         const oldChildren = [];
@@ -1333,16 +1289,12 @@ exports.Renderer = class Renderer {
         const changeCommits = {
             updateComponent: (newAtom, reusedAtom, expectIndex, diffIndex) => {
                 commits.push((offset) => {
-                    const { render, template } = this.componentAtomCaches.get(reusedAtom.jsxNode);
+                    const { render, template } = reusedAtom.jsxNode.$$view;
                     const newProps = newAtom.jsxNode.props;
                     const oldProps = reusedAtom.jsxNode.props;
                     newAtom.jsxNode = reusedAtom.jsxNode;
                     const newTemplate = render(newProps, oldProps);
-                    this.componentAtomCaches.set(newAtom.jsxNode, {
-                        render,
-                        template: newTemplate,
-                        atom: newAtom
-                    });
+                    newAtom.jsxNode.$$view = Object.assign({ render, template: newTemplate, atom: newAtom }, context);
                     if (newTemplate === template) {
                         this.reuseComponentView(newAtom, reusedAtom, context, expectIndex !== diffIndex - offset);
                         return;
@@ -1518,7 +1470,7 @@ exports.Renderer = class Renderer {
     }
     buildView(atom, context) {
         if (atom.jsxNode instanceof Component) {
-            this.componentRender(atom.jsxNode, atom);
+            this.componentRender(atom.jsxNode, atom, context);
             let child = atom.child;
             while (child) {
                 this.buildView(child, context);
@@ -1562,24 +1514,33 @@ exports.Renderer = class Renderer {
             }
         }
     }
-    componentRender(component, from) {
+    componentRender(component, from, context) {
         const { template, render } = component.setup();
         if (template) {
             this.linkTemplate(template, component, from);
         }
-        this.componentAtomCaches.set(component, {
-            render,
-            template,
-            atom: from
-        });
+        component.$$view = Object.assign({ render,
+            template, atom: from }, context);
         return from;
     }
     createChainByComponentFactory(context, factory, parent) {
         const component = factory.createInstance(context);
-        return new Atom(component, parent);
+        return {
+            jsxNode: component,
+            parent,
+            sibling: null,
+            child: null,
+            nativeNode: null
+        };
     }
     createChainByJSXElement(context, element, parent) {
-        const atom = new Atom(element, parent);
+        const atom = {
+            jsxNode: element,
+            parent,
+            sibling: null,
+            child: null,
+            nativeNode: null
+        };
         if (Reflect.has(element.props, 'children')) {
             const jsxChildren = element.props.children;
             const children = this.createChainByChildren(context, Array.isArray(jsxChildren) ? jsxChildren : [jsxChildren], atom, []);
@@ -1588,7 +1549,13 @@ exports.Renderer = class Renderer {
         return atom;
     }
     createChainByJSXText(node, parent) {
-        return new Atom(node, parent);
+        return {
+            jsxNode: node,
+            parent,
+            sibling: null,
+            child: null,
+            nativeNode: null
+        };
     }
     createChainByChildren(context, children, parent, atoms) {
         for (const item of children) {

package/jsx-runtime/index.d.ts

@@ -8,8 +8,7 @@ import { NativeElements } from '@viewfly/platform-browser';
 declare const jsxDEV: typeof jsx;
 export { jsx, jsxs, Fragment, jsxDEV };
 export declare namespace JSX {
-    interface Element extends JSXInternal.Element {
-    }
+    type Element = JSXInternal.Element;
     interface ElementClass extends JSXInternal.ElementClass {
     }
     interface IntrinsicElements extends NativeElements, JSXInternal.IntrinsicElements {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viewfly/core",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "Viewfly is a simple and easy-to-use JavaScript framework with an intuitive development experience.",
   "main": "./bundles/index.js",
   "module": "./bundles/index.esm.js",
@@ -49,5 +49,5 @@
   "bugs": {
     "url": "https://github.com/viewfly/viewfly.git/issues"
   },
-  "gitHead": "74ff7f03fca43463908a7cab8352ae1bf35a7f6c"
+  "gitHead": "2c80fa3f23c647a918d542c0b626384d22766cb8"
 }