@viewfly/core 0.5.3 → 0.6.0

package/bundles/foundation/_utils.d.ts

@@ -1,6 +1,7 @@
-import { JSXComponent, JSXElement, JSXText } from './jsx-element';
+import { JSXNode } from './jsx-element';
 import { NativeNode } from './injection-tokens';
 import { Component } from './component';
+import { JSXInternal } from './types';
 export interface ListenDelegate {
     delegate: () => any;
     listenFn: ((...args: any[]) => any) | void;
@@ -19,14 +20,31 @@ export interface ArrayChanges<T> {
 export declare function getArrayChanges<T>(left: T[], right: T[]): ArrayChanges<T>;
 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 | JSXComponent | Component;
-    parent: Atom | null;
+export interface TextAtom {
+    type: 'text';
+    jsxNode: string;
     nativeNode: NativeNode | null;
     child: Atom | null;
     sibling: Atom | null;
     isSvg: boolean;
 }
+export interface ElementAtom {
+    type: 'element';
+    jsxNode: JSXNode<string>;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    isSvg: boolean;
+}
+export interface ComponentAtom {
+    type: 'component';
+    jsxNode: JSXNode<JSXInternal.ComponentSetup> | Component;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    isSvg: boolean;
+}
+export type Atom = TextAtom | ElementAtom | ComponentAtom;
 export interface ComponentView {
     atom: Atom;
     host: NativeNode;

package/bundles/foundation/component.d.ts

@@ -1,28 +1,27 @@
 import { AbstractType, InjectFlags, InjectionToken, Injector, Provider, ReflectiveInjector, Type } from '../di/_api';
-import { JSXTypeof, Key, Props } from './jsx-element';
+import { Key, Props } from './jsx-element';
 import { ComponentView } from './_utils';
 import { JSXInternal } from './types';
 /**
  * Viewfly 组件管理类，用于管理组件的生命周期，上下文等
  */
-export declare class Component extends ReflectiveInjector implements JSXTypeof<JSXInternal.ComponentSetup> {
-    private parentComponent;
-    type: JSXInternal.ComponentSetup;
+export declare class Component extends ReflectiveInjector {
+    private readonly parentComponent;
+    readonly type: JSXInternal.ComponentSetup;
     props: Props;
-    key?: Key | undefined;
-    $$typeOf: JSXInternal.ComponentSetup<any>;
+    readonly key?: Key | undefined;
     instance: JSXInternal.ComponentInstance<Props>;
-    template: JSXInternal.JSXNode;
+    template: JSXInternal.ViewNode;
     changedSubComponents: Set<Component>;
     get dirty(): boolean;
     get changed(): boolean;
     $$view: ComponentView;
-    unmountedCallbacks: LifeCycleCallback[];
-    mountCallbacks: LifeCycleCallback[];
-    propsChangedCallbacks: PropsChangedCallback<any>[];
-    updatedCallbacks: LifeCycleCallback[];
-    private updatedDestroyCallbacks;
-    private propsChangedDestroyCallbacks;
+    unmountedCallbacks?: LifeCycleCallback[] | null;
+    mountCallbacks?: LifeCycleCallback[] | null;
+    propsChangedCallbacks?: PropsChangedCallback<any>[] | null;
+    updatedCallbacks?: LifeCycleCallback[] | null;
+    private updatedDestroyCallbacks?;
+    private propsChangedDestroyCallbacks?;
     protected _dirty: boolean;
     protected _changed: boolean;
     private unWatch?;

package/bundles/foundation/injection-tokens.d.ts

@@ -12,6 +12,7 @@ export declare abstract class NativeRenderer<ElementNode = NativeNode, TextNode
     abstract listen<T = any>(node: ElementNode, type: string, callback: (ev: T) => any, isSvg: boolean): void;
     abstract unListen(node: ElementNode, type: string, callback: (ev: any) => any, isSvg: boolean): void;
     abstract remove(node: ElementNode | TextNode, isSvg: boolean): void;
+    abstract cleanChildren(node: ElementNode, isSvg: boolean): void;
     abstract syncTextContent(target: TextNode, content: string, isSvg: boolean): void;
     abstract insertAfter(newNode: ElementNode | TextNode, ref: ElementNode | TextNode, isSvg: boolean): void;
 }

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

@@ -1,40 +1,20 @@
-import { Component } from './component';
 import { JSXInternal } from './types';
 import { ListenDelegate } from './_utils';
 export interface Props {
-    children?: JSXInternal.JSXNode | JSXInternal.JSXNode[];
+    children?: JSXInternal.ViewNode | JSXInternal.ViewNode[];
     [key: string]: any;
     [key: symbol]: any;
 }
 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.ComponentSetup, props: Props, key?: Key): JSXComponent;
+export declare function jsx(type: string | JSXInternal.ComponentSetup, props: Props, key?: Key): JSXNode;
 export declare const jsxs: typeof jsx;
-export interface JSXTypeof<T extends string | Symbol | JSXInternal.ComponentSetup = string | Symbol | JSXInternal.ComponentSetup> {
-    $$typeOf: T;
-}
-export declare class JSXText implements JSXTypeof<Symbol> {
-    text: string;
-    $$typeOf: symbol;
-    constructor(text: string);
-}
-export declare class JSXElement implements JSXTypeof<string> {
-    type: string;
+export interface JSXNode<T = string | JSXInternal.ComponentSetup> {
+    type: T;
     props: Props;
-    key?: Key | undefined;
-    $$typeOf: string;
-    static createInstance(type: string, props: Props, key?: Key): JSXElement;
+    key?: Key;
     on?: Record<string, ListenDelegate>;
-    constructor(type: string, props: Props, key?: Key | undefined);
-}
-export declare class JSXComponent implements JSXTypeof<JSXInternal.ComponentSetup> {
-    type: JSXInternal.ComponentSetup;
-    props: Props;
-    factory: (parentComponent: Component) => Component;
-    key?: Key | undefined;
-    static createInstance(type: JSXInternal.ComponentSetup, props: Props, factory: (parentComponent: Component) => Component, key?: Key): JSXComponent;
-    $$typeOf: JSXInternal.ComponentSetup<any>;
-    constructor(type: JSXInternal.ComponentSetup, props: Props, factory: (parentComponent: Component) => Component, key?: Key | undefined);
-    createInstance(parentComponent: Component): Component;
 }
+export declare const JSXNodeFactory: {
+    createNode<T = string | JSXInternal.ComponentSetup<any>>(type: T, props: Props, key?: Key): JSXNode<T>;
+};

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>(canUseMemo: JSXInternal.ComponentInstance<T>['$useMemo'], render: () => JSXInternal.JSXNode): JSXInternal.ComponentInstance<T>;
+export declare function withMemo<T extends Props = Props>(canUseMemo: JSXInternal.ComponentInstance<T>['$useMemo'], render: () => JSXInternal.ViewNode): JSXInternal.ComponentInstance<T>;

package/bundles/foundation/types.d.ts

@@ -2,17 +2,17 @@ import { Key } from './jsx-element';
 import { ExtractInstanceType, DynamicRef } from './component';
 import { Scope } from '../di/injectable';
 import { NativeNode } from './injection-tokens';
-export type JSXNode = JSXInternal.JSXNode;
+export type ViewNode = JSXInternal.ViewNode;
 export declare namespace JSXInternal {
     type ClassNames = string | Record<string, unknown> | false | null | undefined | ClassNames[];
     interface ComponentInstance<P> {
         $portalHost?: NativeNode;
-        $render(): JSXNode;
+        $render(): ViewNode;
         $useMemo?(currentProps: P, prevProps: P): boolean;
     }
-    type JSXNode = Element | JSXInternal.ElementClass | string | number | boolean | null | undefined | JSXNode[];
+    type ViewNode = Element | JSXInternal.ElementClass | string | number | boolean | null | undefined | Iterable<ViewNode>;
     interface ComponentSetup<P = any> {
-        (props: P): (() => Element) | ComponentInstance<P>;
+        (props: P): (() => ViewNode) | ComponentInstance<P>;
         scope?: Scope;
     }
     type Element<P = any, C extends string | ComponentSetup<P> = string | ComponentSetup<P>> = C extends string ? IntrinsicElements[C] : (() => Element) | ComponentInstance<P>;