@viewfly/core 2.0.0-alpha.0 → 2.0.0-alpha.3

package/bundles/index.d.ts

@@ -169,10 +169,10 @@ declare function normalizeProvider(provider: Provider): NormalizedProvider;
  */
 declare class ReflectiveInjector implements Injector {
     parentInjector: Injector | null;
-    protected scope?: Scope | undefined;
+    protected scope?: Scope | null | undefined;
     protected normalizedProviders: NormalizedProvider[];
     protected recordValues: Map<Type<any> | AbstractType<any> | InjectionToken<any>, any>;
-    constructor(parentInjector: Injector | null, staticProviders: Provider[], scope?: Scope | undefined);
+    constructor(parentInjector: Injector | null, staticProviders: Provider[], scope?: Scope | null | undefined);
     /**
      * 用于获取当前注入器上下文内的实例、对象或数据
      * @param token 访问 token
@@ -207,6 +207,7 @@ declare const JSXNodeFactory: {
     createNode<T = string | ComponentSetup<any>>(type: T, props: Props & Record<string, any>, key?: Key): ViewFlyNode<T>;
 };
 
+declare function comparePropsWithCallbacks(oldProps: Record<string, any>, newProps: Record<string, any>, onDeleted: (key: string, oldValue: any) => void, onAdded: (key: string, value: any) => void, onUpdated: (key: string, newValue: any, oldValue: any) => void): void;
 declare const TextAtomType: unique symbol;
 declare const ElementAtomType: unique symbol;
 declare const ComponentAtomType: unique symbol;
@@ -245,12 +246,6 @@ interface ComponentAtom {
     namespace: ElementNamespace;
 }
 type Atom = TextAtom | ElementAtom | ComponentAtom;
-interface ComponentView {
-    atom: ComponentAtom;
-    host: NativeNode;
-    isParent: boolean;
-    rootHost: NativeNode;
-}
 
 type NativeNode = Record<string, any>;
 declare abstract class NativeRenderer<ElementNode = NativeNode, TextNode = NativeNode> {
@@ -376,29 +371,6 @@ declare function onMounted(callback: LifeCycleCallback): void;
  * ```
  */
 declare function onUpdated(callback: LifeCycleCallback): () => void;
-interface PropsChangedCallback<T extends Props> {
-    (currentProps: T, oldProps: T): void | (() => void);
-}
-/**
- * 当组件 props 更新地调用
- * @param callback
- * @example
- * ```tsx
- * function YourComponent(props) {
- *   onPropsChanged((currentProps, prevProps) => {
- *     console.log(currentProps, prevProps)
- *
- *     return () => {
- *       console.log('destroy prev changed!')
- *     }
- *   })
- *   return () => {
- *     return <div>xxx</div>
- *   }
- * }
- * ```
- */
-declare function onPropsChanged<T extends Props>(callback: PropsChangedCallback<T>): () => void;
 /**
  * 当组件销毁时调用回调函数
  * @param callback
@@ -416,37 +388,47 @@ type JSXNode = JSX.Element | JSX.ElementClass | string | number | boolean | null
 interface ComponentSetup<P = any> {
     (props: P): (() => JSXNode) | ComponentInstance<P>;
 }
+interface ComponentViewMetadata {
+    atom: ComponentAtom;
+    host: NativeNode;
+    isParent: boolean;
+    rootHost: NativeNode;
+}
 /**
  * Viewfly 组件管理类，用于管理组件的生命周期，上下文等
  */
 declare class Component {
     readonly parentComponent: Component | null;
     readonly type: ComponentSetup;
-    props: Props;
-    readonly key?: Key | undefined;
+    props: Record<string, any>;
+    readonly key?: Key;
     instance: ComponentInstance<Props>;
     changedSubComponents: Set<Component>;
     get dirty(): boolean;
     get changed(): boolean;
+    /**
+     * @internal
+     */
+    viewMetadata: ComponentViewMetadata;
     unmountedCallbacks?: LifeCycleCallback[] | null;
     mountCallbacks?: LifeCycleCallback[] | null;
-    propsChangedCallbacks?: PropsChangedCallback<any>[] | null;
     updatedCallbacks?: LifeCycleCallback[] | null;
     private updatedDestroyCallbacks?;
-    private propsChangedDestroyCallbacks?;
     protected _dirty: boolean;
     protected _changed: boolean;
     private isFirstRendering;
+    private rawProps;
     private refs;
     private listener;
-    constructor(parentComponent: Component | null, type: ComponentSetup, props: Props, key?: Key | undefined);
+    constructor(parentComponent: Component | null, type: ComponentSetup, props: Record<string, any>, key?: Key);
     markAsDirtied(): void;
     markAsChanged(changedComponent?: Component): void;
     render(update: (template: JSXNode, portalHost?: NativeNode) => void): void;
-    update(newProps: Record<string, any>, updateChildren: (jsxNode: JSXNode) => void, reuseChildren: (skipSubComponentDiff: boolean) => void): void;
+    updateProps(newProps: Record<string, any>): void;
+    canUpdate(oldProps: Record<string, any>, newProps: Record<string, any>): boolean;
+    rerender(): JSXNode;
     destroy(): void;
     rendered(): void;
-    private invokePropsChangedHooks;
     private invokeMountHooks;
     private invokeUpdatedHooks;
 }
@@ -455,15 +437,42 @@ declare class Component {
  */
 declare function getCurrentInstance(): Component;
 
-declare function createContext(providers: Provider[], scope?: Scope, parentInjector?: Injector): (props: Props) => () => JSXNode | JSXNode[];
+declare function createContext(providers: Provider[], scope?: Scope | null, parentInjector?: Injector): (props: Props) => () => JSXNode | JSXNode[];
 /**
  * 通过组件上下文获取 IoC 容器内数据的勾子方法
  */
 declare function inject<T extends Type<any> | AbstractType<any> | InjectionToken<any>, U = never>(token: T, notFoundValue?: U, flags?: InjectFlags): ExtractValueType<T> | U;
+interface ComponentAnnotation {
+    scope?: Scope;
+    providers?: Provider[];
+}
+/**
+ * 给组件添加注解
+ * @param annotation
+ * @param componentSetup
+ * @example
+ * ```ts
+ * export customScope = new Scope('scopeName')
+ * export const App = withAnnotation({
+ *   scope: customScope,
+ *   providers: [
+ *     ExampleService
+ *   ]
+ * }, function(props: Props) {
+ *   return () => {
+ *     return <div>...</div>
+ *   }
+ * })
+ * ```
+ */
+declare function withAnnotation<T extends ComponentSetup>(annotation: ComponentAnnotation, componentSetup: T): T;
 
 declare function withMemo<T extends Props = Props>(canUseMemo: ComponentInstance<T>['$useMemo'], render: () => JSXNode): ComponentInstance<T>;
 
-declare const ElementNamespaceMap: Record<string, string>;
+declare const ElementNamespaceMap: {
+    readonly svg: "svg";
+    readonly math: "mathml";
+};
 declare function createRenderer(component: Component, nativeRenderer: NativeRenderer, namespace: ElementNamespace): (host: NativeNode) => void;
 
 /**
@@ -475,75 +484,6 @@ declare class RootComponent extends Component {
     markAsChanged(changedComponent?: Component): void;
 }
 
-/**
- * 组件状态实例，直接调用可以获取最新的状态，通过 set 方法可以更新状态
- */
-interface Signal<T> {
-    /**
-     *  直接调用一个 Signal 实例，可以获取最新状态
-     */
-    (): T;
-    /**
-     * 更新组件状态的方法，可以传入最新的值
-     * @param newState
-     */
-    set(newState: T): void;
-}
-/**
- * 组件状态管理器
- * @param state 初始状态
- * @example
- * ```tsx
- * function App() {
- *   // 初始化状态
- *   const state = createSignal(1)
- *
- *   return () => {
- *     <div>
- *       <div>当前值为：{state()}</div>
- *       <div>
- *         <button type="button" onClick={() => {
- *           // 当点击时更新状态
- *           state.set(state() + 1)
- *         }
- *         }>updateState</button>
- *       </div>
- *     </div>
- *   }
- * }
- */
-declare function createSignal<T>(state: T): Signal<T>;
-/**
- * 使用派生值，Viewfly 会收集回调函数内同步执行时访问的 Signal，
- * 并在你获取 createDerived 函数返回的 Signal 的值时，自动计算最新的值。
- *
- * @param fn
- * @param isContinue 可选的停止函数，在每次值更新后调用，当返回值为 false 时，将不再监听依赖的变化
- */
-declare function computed<T>(fn: () => T, isContinue?: (data: T) => unknown): Signal<T>;
-declare const createDerived: typeof computed;
-interface WatchCallback<T> {
-    (newValue: T, oldValue: T): void | (() => void);
-}
-/**
- * 监听状态变化，当任意一个状态发生变更时，触发回调。
- * watch 会返回一个取消监听的函数，调用此函数，可以取消监听。
- * 当在组件中调用时，组件销毁时会自动取消监听。
- * @param deps 依赖的状态 Signal，可以是一个 Signal，只可以一个数包含 Signal 的数组，或者是一个求值函数
- * @param callback 状态变更后的回调函数
- */
-declare function watch<T>(deps: Signal<T>, callback: WatchCallback<T>): () => void;
-declare function watch<T>(deps: [Signal<T>], callback: WatchCallback<[T]>): () => void;
-declare function watch<T, T1>(deps: [Signal<T>, Signal<T1>], callback: WatchCallback<[T, T1]>): () => void;
-declare function watch<T, T1, T2>(deps: [Signal<T>, Signal<T1>, Signal<T2>], callback: WatchCallback<[T, T1, T2]>): () => void;
-declare function watch<T, T1, T2, T3>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>], callback: WatchCallback<[T, T1, T2, T3]>): () => void;
-declare function watch<T, T1, T2, T3, T4>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>], callback: WatchCallback<[T, T1, T2, T3, T4]>): () => void;
-declare function watch<T, T1, T2, T3, T4, T5>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>, Signal<T5>], callback: WatchCallback<[T, T1, T2, T3, T4, T5]>): () => void;
-declare function watch<T, T1, T2, T3, T4, T5, T6>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>, Signal<T5>, Signal<T6>], callback: WatchCallback<[T, T1, T2, T3, T4, T5, T6]>): () => void;
-declare function watch<T, T1, T2, T3, T4, T5, T6, T7>(deps: [Signal<T>, Signal<T1>, Signal<T2>, Signal<T3>, Signal<T4>, Signal<T5>, Signal<T6>, Signal<T7>], callback: WatchCallback<[T, T1, T2, T3, T4, T5, T6, T7]>): () => void;
-declare function watch<T>(deps: () => T, callback: WatchCallback<T>): () => void;
-declare function watch<T = any>(deps: Signal<any>[], callback: WatchCallback<T[]>): () => void;
-
 /**
  * Viewfly 配置项
  */
@@ -573,4 +513,131 @@ interface Module {
 }
 declare function viewfly<T extends NativeNode>(config: Config): Application<T>;
 
-export { type AbstractInstanceType, type AbstractProvider, type AbstractType, type Application, type Atom, type ClassNames, type ClassProvider, Component, type ComponentInstance, type ComponentSetup, type ComponentView, type Config, type ConstructorProvider, DynamicRef, type ElementNamespace, ElementNamespaceMap, type ExistingProvider, type ExtractInstanceType, type ExtractValueType, type FactoryProvider, ForwardRef, Fragment, Inject, type InjectDecorator, InjectFlags, Injectable, type InjectableDecorator, type InjectableOptions, InjectionToken, Injector, JSX, type JSXNode, JSXNodeFactory, type Key, type LifeCycleCallback, type Module, type NativeNode, NativeRenderer, type NormalizedProvider, NullInjector, Optional, type OptionalDecorator, Prop, type PropDecorator, type Props, type PropsChangedCallback, type ProvideScope, type Provider, type RefListener, type ReflectiveDependency, ReflectiveInjector, RootComponent, Scope, Self, type SelfDecorator, type Signal, SkipSelf, type SkipSelfDecorator, type StaticProvider, StaticRef, THROW_IF_NOT_FOUND, Type, type TypeProvider, type ValueProvider, type ViewFlyNode, type WatchCallback, computed, createContext, createDerived, createDynamicRef, createRef, createRenderer, createSignal, forwardRef, getCurrentInstance, getSetupContext, inject, jsx, jsxs, makeError, normalizeProvider, onMounted, onPropsChanged, onUnmounted, onUpdated, viewfly, watch, withMemo };
+interface Computed<T> {
+    readonly value: T;
+}
+declare function computed<T>(callback: () => T, isContinue?: (data: T) => unknown): Computed<T>;
+
+declare class Dep {
+    effect: () => void;
+    destroyCallbacks: Array<() => void>;
+    constructor(effect: () => void);
+    destroy(): void;
+}
+declare function getDepContext(): Dep | undefined;
+declare function pushDepContext(dep: Dep): void;
+declare function popDepContext(): void;
+declare enum TrackOpTypes {
+    Get = "Get",
+    Has = "Has",
+    Iterate = "Iterate"
+}
+declare enum TriggerOpTypes {
+    Set = "Set",
+    Add = "Add",
+    Delete = "Delete",
+    Clear = "Clear"
+}
+declare function track(target: object, type: TrackOpTypes, key?: unknown): void;
+declare function trigger(target: object, type: TriggerOpTypes, key?: unknown): void;
+declare function registryComponentDestroyCallback(fn: () => void): void;
+
+declare const rawToProxyCache: WeakMap<object, any>;
+declare const proxyToRawCache: WeakMap<object, any>;
+declare function toRaw<T>(value: T): T;
+declare function isReactive(value: any): boolean;
+interface ReactiveConfig {
+    readonly: boolean;
+    shallow: boolean;
+}
+declare function internalWrite(fn: () => void): void;
+declare class ObjectReactiveHandler<T extends object> implements ProxyHandler<T> {
+    protected isShallow: boolean;
+    protected isReadonly: boolean;
+    constructor(config: ReactiveConfig);
+    set(target: T, p: string | symbol, newValue: any, receiver: any): boolean;
+    get(target: T, p: string | symbol, receiver: any): any;
+    deleteProperty(target: T, p: string | symbol): boolean;
+    ownKeys(target: T): ArrayLike<string | symbol>;
+}
+declare class ArrayReactiveHandler extends ObjectReactiveHandler<any[]> {
+    interceptors: {
+        entries(): Generator<unknown[], void, unknown>;
+        keys(): Generator<unknown, void, unknown>;
+        values(): Generator<unknown, void, unknown>;
+        concat(this: any, ...items: any[]): any[];
+        every(this: any, predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: unknown): any;
+        filter(this: any, predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): any;
+        find(predicate: (value: unknown, index: number, obj: unknown[]) => unknown, thisArg?: any): any;
+        findIndex(predicate: (value: unknown, index: number, obj: unknown[]) => unknown, thisArg?: any): number;
+        findLast(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): any;
+        findLastIndex(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): number;
+        forEach(callbackfn: (value: unknown, index: number, array: unknown[]) => void, thisArg?: any): any;
+        includes(...args: unknown[]): boolean;
+        indexOf(...args: unknown[]): number;
+        join(separator?: string | undefined): string;
+        lastIndexOf(...args: unknown[]): number;
+        map<U>(callbackFn: (value: unknown, index: number, array: unknown[]) => U, thisArg?: any): U[];
+        pop(): any;
+        push(this: any, ...items: any[]): any;
+        reduce(callbackFn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: unknown[]) => unknown, ...args: any[]): any;
+        reduceRight(callbackFn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: unknown[]) => unknown, ...args: any[]): any;
+        shift(): any;
+        some(predicate: (value: unknown, index: number, array: unknown[]) => unknown, thisArg?: any): boolean;
+        splice(start: number, deleteCount?: number | undefined): unknown[];
+        toReversed(): any;
+        toSorted(compareFn?: ((a: unknown, b: unknown) => number) | undefined): any;
+        toSpliced(start: number, deleteCount: number, ...items: any[]): any;
+        unshift(...items: any[]): number;
+        [Symbol.iterator](): Generator<unknown, void, unknown>;
+    };
+    constructor(config: ReactiveConfig);
+    get(target: any[], p: string | symbol, receiver: any): any;
+}
+declare class MapReactiveHandler extends ObjectReactiveHandler<Map<any, any> | WeakMap<object, any>> {
+    interceptors: {
+        entries(): Generator<unknown[], void, unknown>;
+        keys(): Generator<unknown, void, unknown>;
+        values(): Generator<unknown, void, unknown>;
+        get(this: any, key: any): unknown;
+        set(this: any, key: any, value: any): Map<any, any>;
+        has(this: any, key: any): any;
+        delete(this: any, key: any): any;
+        forEach(this: any, callbackFn: (value: any, key: any, map: Map<any, any>) => void, thisArg?: any): void;
+        clear(this: any): void;
+        [Symbol.iterator](): Generator<unknown[], void, unknown>;
+    };
+    constructor(config: ReactiveConfig);
+    get(target: Map<any, any> | WeakMap<object, any>, p: string | symbol, receiver: any): any;
+}
+declare class SetReactiveHandler extends ObjectReactiveHandler<Set<any> | WeakSet<object>> {
+    interceptors: {
+        entries(): Generator<unknown[], void, unknown>;
+        keys(): Generator<unknown, void, unknown>;
+        values(): Generator<unknown, void, unknown>;
+        add(this: any, value: any): any;
+        delete(this: any, value: any): any;
+        has(this: any, key: any): any;
+        forEach(this: any, callbackFn: (value: any, value2: any, set: Set<any>) => void, thisArg?: any): void;
+        clear(this: any): void;
+        [Symbol.iterator](): Generator<unknown, void, unknown>;
+    };
+    constructor(config: ReactiveConfig);
+    get(target: Set<any> | WeakSet<object>, p: string | symbol, receiver: any): any;
+}
+declare const defaultObjectReactiveHandler: ObjectReactiveHandler<object>;
+declare const defaultArrayReactiveHandler: ArrayReactiveHandler;
+declare const defaultMapReactiveHandler: MapReactiveHandler;
+declare const defaultSetReactiveHandler: SetReactiveHandler;
+declare const readonlyProxyHandler: ObjectReactiveHandler<object>;
+declare function reactive<T>(raw: T): T;
+
+declare const defaultShallowObjectReactiveHandler: ObjectReactiveHandler<object>;
+declare const defaultShallowArrayReactiveHandler: ArrayReactiveHandler;
+declare const defaultShallowMapReactiveHandler: MapReactiveHandler;
+declare const defaultShallowSetReactiveHandler: SetReactiveHandler;
+declare function shallowReactive<T>(raw: T): T;
+
+declare function watch<T>(trigger: () => T, callback: (newValue: T, oldValue: T) => (() => any) | void): () => void;
+
+export { type AbstractInstanceType, type AbstractProvider, type AbstractType, type Application, ArrayReactiveHandler, type Atom, type ClassNames, type ClassProvider, Component, type ComponentAnnotation, type ComponentInstance, type ComponentSetup, type ComponentViewMetadata, type Computed, type Config, type ConstructorProvider, Dep, DynamicRef, type ElementNamespace, ElementNamespaceMap, type ExistingProvider, type ExtractInstanceType, type ExtractValueType, type FactoryProvider, ForwardRef, Fragment, Inject, type InjectDecorator, InjectFlags, Injectable, type InjectableDecorator, type InjectableOptions, InjectionToken, Injector, JSX, type JSXNode, JSXNodeFactory, type Key, type LifeCycleCallback, MapReactiveHandler, type Module, type NativeNode, NativeRenderer, type NormalizedProvider, NullInjector, ObjectReactiveHandler, Optional, type OptionalDecorator, Prop, type PropDecorator, type Props, type ProvideScope, type Provider, type ReactiveConfig, type RefListener, type ReflectiveDependency, ReflectiveInjector, RootComponent, Scope, Self, type SelfDecorator, SetReactiveHandler, SkipSelf, type SkipSelfDecorator, type StaticProvider, StaticRef, THROW_IF_NOT_FOUND, TrackOpTypes, TriggerOpTypes, Type, type TypeProvider, type ValueProvider, type ViewFlyNode, comparePropsWithCallbacks, computed, createContext, createDynamicRef, createRef, createRenderer, defaultArrayReactiveHandler, defaultMapReactiveHandler, defaultObjectReactiveHandler, defaultSetReactiveHandler, defaultShallowArrayReactiveHandler, defaultShallowMapReactiveHandler, defaultShallowObjectReactiveHandler, defaultShallowSetReactiveHandler, forwardRef, getCurrentInstance, getDepContext, getSetupContext, inject, internalWrite, isReactive, jsx, jsxs, makeError, normalizeProvider, onMounted, onUnmounted, onUpdated, popDepContext, proxyToRawCache, pushDepContext, rawToProxyCache, reactive, readonlyProxyHandler, registryComponentDestroyCallback, shallowReactive, toRaw, track, trigger, viewfly, watch, withAnnotation, withMemo };