@viewfly/core 1.0.0-alpha.9 → 1.0.1

package/bundles/index.d.ts

@@ -0,0 +1,595 @@
+declare class ForwardRef<T = any> {
+    private forwardRefFn;
+    constructor(forwardRefFn: () => T);
+    getRef(): T;
+}
+/**
+ * 引用后声明的类的工具函数
+ * @param fn
+ */
+declare function forwardRef<T>(fn: () => T): ForwardRef<T>;
+
+declare class Scope {
+    name: string;
+    constructor(name: string);
+    toString(): string;
+}
+type ProvideScope = 'root' | Scope;
+interface InjectableOptions {
+    provideIn: ProvideScope;
+}
+interface InjectableDecorator {
+    (options?: InjectableOptions): ClassDecorator;
+    new (options?: InjectableOptions): Injectable;
+}
+interface Injectable {
+    provideIn?: ProvideScope;
+}
+/**
+ * 可注入类的装饰器
+ */
+declare const Injectable: InjectableDecorator;
+
+/**
+ * 生成自定义依赖注入 token 的类
+ */
+declare class InjectionToken<T> {
+    readonly description: string;
+    constructor(description: string);
+    toString(): string;
+}
+
+declare const Type: FunctionConstructor;
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+interface AbstractType<T> extends Function {
+    prototype: T;
+}
+
+/**
+ * 查找规则
+ */
+declare enum InjectFlags {
+    /** 默认查找规则 */
+    Default = "Default",
+    /** 锁定当前容器 */
+    Self = "Self",
+    /** 跳过当前容器 */
+    SkipSelf = "SkipSelf",
+    /** 可选查找 */
+    Optional = "Optional"
+}
+/**
+ * 根据 token 推断返回数据类型
+ */
+type ExtractValueType<T> = T extends Type<any> ? InstanceType<T> : T extends AbstractType<infer K> ? K : T extends InjectionToken<infer V> ? V : never;
+/**
+ * DI 容器抽象基类
+ */
+declare abstract class Injector {
+    abstract parentInjector: Injector | null;
+    abstract get<T extends Type<any> | AbstractType<any> | InjectionToken<any>, U = never>(token: T, notFoundValue?: U, flags?: InjectFlags): ExtractValueType<T> | U;
+}
+
+interface InjectDecorator {
+    (token: InjectionToken<any> | Type<any> | ForwardRef<InjectionToken<any> | Type<any>>): ParameterDecorator;
+    new (token: InjectionToken<any> | Type<any> | ForwardRef<InjectionToken<any> | Type<any>>): Inject;
+}
+interface Inject {
+    token: InjectionToken<any> | Type<any> | ForwardRef<InjectionToken<any> | Type<any>>;
+}
+/**
+ * 构造函数参数装饰器，用于改变注入 token
+ */
+declare const Inject: InjectDecorator;
+interface SelfDecorator {
+    (): ParameterDecorator;
+    new (): Self;
+}
+interface Self {
+}
+declare const Self: SelfDecorator;
+interface SkipSelfDecorator {
+    (): ParameterDecorator;
+    new (): SkipSelf;
+}
+interface SkipSelf {
+}
+declare const SkipSelf: SkipSelfDecorator;
+interface OptionalDecorator {
+    (): ParameterDecorator;
+    new (): Optional;
+}
+interface Optional {
+}
+declare const Optional: OptionalDecorator;
+interface PropDecorator {
+    <T extends Type<any> | AbstractType<any> | InjectionToken<any>, U = never>(token?: T | ForwardRef<ExtractValueType<T>>, notFoundValue?: U, flags?: InjectFlags): PropertyDecorator;
+    new (token: any): Prop;
+}
+interface Prop {
+}
+declare const Prop: PropDecorator;
+
+declare const THROW_IF_NOT_FOUND: any;
+declare class NullInjector implements Injector {
+    parentInjector: null;
+    get(token: any, notFoundValue?: any, _?: InjectFlags): any;
+}
+
+interface ClassProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useClass: Type<T>;
+    deps?: any[];
+}
+interface FactoryProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useFactory: (...args: any[]) => T;
+    deps?: any[];
+}
+interface ValueProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useValue: T;
+}
+interface ExistingProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useExisting: T;
+}
+interface ConstructorProvider<T = any> {
+    provide: Type<T>;
+    deps?: [];
+}
+interface TypeProvider<T = any> extends Type<T> {
+}
+interface AbstractProvider<T = any> extends AbstractType<T> {
+}
+type StaticProvider<T = any> = ClassProvider<T> | FactoryProvider<T> | ValueProvider<T> | ExistingProvider<T> | ConstructorProvider<T>;
+type Provider<T = any> = TypeProvider<T> | AbstractProvider<T> | StaticProvider<T>;
+
+interface ReflectiveDependency {
+    injectKey: any;
+    visibility: SkipSelf | Self | null;
+    optional: boolean;
+}
+interface NormalizedProvider {
+    provide: any;
+    generateFactory: (injector: Injector, cacheFn: (token: any, value: any) => void) => (...args: any[]) => any;
+    deps: ReflectiveDependency[];
+    scope: ProvideScope | null;
+}
+/**
+ * 标准化 provide，并返回统一数据结构
+ * @param provider
+ */
+declare function normalizeProvider(provider: Provider): NormalizedProvider;
+
+/**
+ * 反射注入器
+ */
+declare class ReflectiveInjector implements Injector {
+    parentInjector: Injector | null;
+    protected scope?: Scope | undefined;
+    protected normalizedProviders: NormalizedProvider[];
+    protected recordValues: Map<Type<any> | AbstractType<any> | InjectionToken<any>, any>;
+    constructor(parentInjector: Injector | null, staticProviders: Provider[], scope?: Scope | undefined);
+    /**
+     * 用于获取当前注入器上下文内的实例、对象或数据
+     * @param token 访问 token
+     * @param notFoundValue 如未查找到的返回值
+     * @param flags 查询规则
+     */
+    get<T extends Type<any> | AbstractType<any> | InjectionToken<any>, U = never>(token: T, notFoundValue?: U, flags?: InjectFlags): ExtractValueType<T> | U;
+    private getValue;
+    /**
+     * 解决并获取依赖参数
+     * @param deps 依赖规则
+     * @private
+     */
+    private resolveDeps;
+}
+
+declare function makeError(name: string): (message: string) => Error;
+
+interface Props {
+    children?: JSXNode | JSXNode[];
+}
+declare function Fragment(props: Props): () => JSXNode | JSXNode[];
+type Key = number | string;
+declare function jsx(type: string | ComponentSetup, props: Props & Record<string, any>, key?: Key): ViewFlyNode;
+declare const jsxs: typeof jsx;
+interface ViewFlyNode<T = string | ComponentSetup> {
+    type: T;
+    props: Props & Record<string, any>;
+    key?: Key;
+}
+declare const JSXNodeFactory: {
+    createNode<T = string | ComponentSetup<any>>(type: T, props: Props & Record<string, any>, key?: Key): ViewFlyNode<T>;
+};
+
+type NativeNode = Record<string, any>;
+declare abstract class NativeRenderer<ElementNode = NativeNode, TextNode = NativeNode> {
+    abstract createElement(name: string, isSvg: boolean): ElementNode;
+    abstract createTextNode(textContent: string, isSvg: boolean): TextNode;
+    abstract setProperty(node: ElementNode, key: string, value: any, isSvg: boolean): void;
+    abstract appendChild(parent: ElementNode, newChild: ElementNode | TextNode, isSvg: boolean): void;
+    abstract prependChild(parent: ElementNode, newChild: ElementNode | TextNode, isSvg: boolean): void;
+    abstract removeProperty(node: ElementNode, key: string, isSvg: boolean): void;
+    abstract setStyle(target: ElementNode, key: string, value: any, isSvg: boolean): void;
+    abstract removeStyle(target: ElementNode, key: string, isSvg: boolean): void;
+    abstract setClass(target: ElementNode, value: string, isSvg: boolean): void;
+    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;
+}
+
+declare namespace JSX {
+    type ElementType = keyof IntrinsicElements | ComponentSetup;
+    interface Element extends ViewFlyNode {
+    }
+    interface KeyedAttributes {
+        key?: Key;
+    }
+    interface IntrinsicAttributes extends KeyedAttributes {
+        ref?: any;
+        [key: string]: any;
+    }
+    interface RefAttributes<T> extends KeyedAttributes {
+        ref?: DynamicRef<ExtractInstanceType<T>> | DynamicRef<ExtractInstanceType<T>>[];
+    }
+    interface ElementClass<P = any> extends ComponentInstance<P> {
+    }
+    interface ElementChildrenAttribute {
+    }
+    interface IntrinsicElements {
+        [name: string]: any;
+    }
+    interface IntrinsicClassAttributes<T> {
+        ref?: DynamicRef<T>;
+    }
+}
+
+type ClassNames = string | Record<string, unknown> | false | null | undefined | ClassNames[];
+interface ComponentInstance<P> {
+    $portalHost?: NativeNode;
+    $render(): JSXNode;
+    $useMemo?(currentProps: P, prevProps: P): boolean;
+}
+type JSXNode = JSX.Element | JSX.ElementClass | string | number | boolean | null | undefined | Iterable<JSXNode>;
+interface ComponentAnnotation {
+    scope?: Scope;
+    providers?: Provider[];
+}
+interface ComponentSetup<P = any> {
+    (props: P): (() => JSXNode) | ComponentInstance<P>;
+    annotation?: ComponentAnnotation;
+}
+/**
+ * Viewfly 组件管理类，用于管理组件的生命周期，上下文等
+ */
+declare class Component extends ReflectiveInjector {
+    private readonly parentComponent;
+    readonly type: ComponentSetup;
+    props: Props;
+    readonly key?: Key | undefined;
+    instance: ComponentInstance<Props>;
+    template: JSXNode;
+    changedSubComponents: Set<Component>;
+    get dirty(): boolean;
+    get changed(): boolean;
+    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?;
+    private isFirstRendering;
+    private refs;
+    constructor(parentComponent: Injector | null, type: ComponentSetup, props: Props, key?: Key | undefined);
+    markAsDirtied(): void;
+    markAsChanged(changedComponent?: Component): void;
+    render(): {
+        template: JSXNode;
+        portalHost: NativeNode | undefined;
+    };
+    update(newProps: Record<string, any>): JSXNode;
+    provide<T>(providers: Provider<T> | Provider<T>[]): void;
+    rendered(): void;
+    destroy(): void;
+    private invokePropsChangedHooks;
+    private invokeMountHooks;
+    private invokeUpdatedHooks;
+}
+interface LifeCycleCallback {
+    (): void | (() => void);
+}
+interface PropsChangedCallback<T extends Props> {
+    (currentProps: T | null, oldProps: T | null): void | (() => void);
+}
+/**
+ * 当组件第一次渲染完成时触发
+ * @param callback
+ * ```tsx
+ * function App() {
+ *   onMount(() => {
+ *     console.log('App mounted!')
+ *   })
+ *   return () => <div>...</div>
+ * }
+ * ```
+ */
+declare function onMounted(callback: LifeCycleCallback): void;
+/**
+ * 当组件视图更新后调用
+ * @param callback
+ * ```tsx
+ * function App() {
+ *   onUpdated(() => {
+ *     console.log('App updated!')
+ *     return () => {
+ *       console.log('destroy prev update!')
+ *     }
+ *   })
+ *   return () => <div>...</div>
+ * }
+ * ```
+ */
+declare function onUpdated(callback: LifeCycleCallback): () => 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
+ */
+declare function onUnmounted(callback: () => void): void;
+interface RefListener<T> {
+    (current: T): void | (() => void);
+}
+type ExtractInstanceType<T, U = T extends (...args: any) => any ? ReturnType<T> : T> = U extends ComponentInstance<any> ? Omit<U, keyof ComponentInstance<any>> : U extends Function ? never : T;
+interface AbstractInstanceType<T extends Record<string, any>> {
+    (): T & ComponentInstance<any>;
+}
+declare class DynamicRef<T> {
+    private callback;
+    private unBindMap;
+    private targetCaches;
+    constructor(callback: RefListener<T>);
+    bind(value: T): void;
+    unBind(value: T): void;
+}
+/**
+ * 用于节点渲染完成时获取 DOM 节点
+ * @param callback 获取 DOM 节点的回调函数
+ * @example
+ * ```tsx
+ * function App() {
+ *   const ref = createDynamicRef(node => {
+ *     function fn() {
+ *       // do something...
+ *     }
+ *     node.addEventListener('click', fn)
+ *     return () => {
+ *       node.removeEventListener('click', fn)
+ *     }
+ *   })
+ *   return () => {
+ *     return <div ref={ref}>xxx</div>
+ *   }
+ * }
+ * ```
+ */
+declare function createDynamicRef<T, U = ExtractInstanceType<T>>(callback: RefListener<U>): DynamicRef<U>;
+declare class StaticRef<T> extends DynamicRef<T> {
+    readonly current: T | null;
+    constructor();
+}
+declare function createRef<T, U = ExtractInstanceType<T>>(): StaticRef<U>;
+declare const depsKey: unique symbol;
+/**
+ * 组件状态实例，直接调用可以获取最新的状态，通过 set 方法可以更新状态
+ * ```
+ */
+interface Signal<T> {
+    $isSignal: true;
+    /**
+     *  直接调用一个 Signal 实例，可以获取最新状态
+     */
+    (): T;
+    /**
+     * 更新组件状态的方法，可以传入最新的值
+     * @param newState
+     */
+    set(newState: T): void;
+    [depsKey]: Set<LifeCycleCallback>;
+}
+/**
+ * 组件状态管理器
+ * @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，
+ * 并在你获取 useDerived 函数返回的 Signal 的值时，自动计算最新的值。
+ *
+ * @param callback
+ * @param isContinue 可选的停止函数，在每次值更新后调用，当返回值为 false 时，将不再监听依赖的变化
+ */
+declare function createDerived<T>(callback: () => T, isContinue?: (data: T) => unknown): Signal<T>;
+interface WatchCallback<T, U> {
+    (newValue: T, oldValue: U): void | (() => void);
+}
+/**
+ * 监听状态变化，当任意一个状态发生变更时，触发回调。
+ * watch 会返回一个取消监听的函数，调用此函数，可以取消监听。
+ * 当在组件中调用时，组件销毁时会自动取消监听。
+ * @param deps 依赖的状态 Signal，可以是一个 Signal，只可以一个数包含 Signal 的数组，或者是一个求值函数
+ * @param callback 状态变更后的回调函数
+ */
+declare function watch<T>(deps: Signal<T>, callback: WatchCallback<T, T>): () => void;
+declare function watch<T>(deps: [Signal<T>], callback: WatchCallback<[T], [T]>): () => void;
+declare function watch<T, T1>(deps: [Signal<T>, Signal<T1>], callback: WatchCallback<[T, T1], [T, T1]>): () => void;
+declare function watch<T, T1, T2>(deps: [Signal<T>, Signal<T1>, Signal<T2>], callback: WatchCallback<[T, T1, T2], [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], [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], [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], [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], [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], [T, T1, T2, T3, T4, T5, T6, T7]>): () => void;
+declare function watch<T>(deps: () => T, callback: WatchCallback<T, T>): () => void;
+declare function watch<T = any>(deps: Signal<any>[], callback: WatchCallback<T[], T[]>): () => void;
+/**
+ * 给组件添加注解
+ * @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;
+/**
+ * 通过组件上下文获取 IoC 容器内数据的勾子方法
+ */
+declare function inject<T extends Type<any> | AbstractType<any> | InjectionToken<any>, U = never>(token: T, notFoundValue?: U, flags?: InjectFlags): ExtractValueType<T> | U;
+/**
+ * 获取当前组件实例
+ */
+declare function getCurrentInstance(): Component;
+
+declare function withMemo<T extends Props = Props>(canUseMemo: ComponentInstance<T>['$useMemo'], render: () => JSXNode): ComponentInstance<T>;
+
+declare function createRenderer(component: Component, nativeRenderer: NativeRenderer): (host: NativeNode) => void;
+
+/**
+ * Viewfly 根组件，用于实现组件状态更新事件通知
+ */
+declare class RootComponent extends Component {
+    private refresh;
+    constructor(parentInjector: Injector | null, factory: ComponentSetup, refresh: () => void);
+    markAsChanged(changedComponent?: Component): void;
+}
+
+declare const TextAtomType: unique symbol;
+declare const ElementAtomType: unique symbol;
+declare const ComponentAtomType: unique symbol;
+interface TextAtom {
+    type: typeof TextAtomType;
+    index: number;
+    jsxNode: string;
+    nodeType: string;
+    key?: null;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    isSvg: boolean;
+}
+interface ElementAtom {
+    type: typeof ElementAtomType;
+    index: number;
+    nodeType: string;
+    key?: Key;
+    jsxNode: ViewFlyNode<string>;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    isSvg: boolean;
+}
+interface ComponentAtom {
+    type: typeof ComponentAtomType;
+    index: number;
+    nodeType: ComponentSetup;
+    key?: Key;
+    jsxNode: ViewFlyNode<ComponentSetup> | Component;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    isSvg: boolean;
+}
+type Atom = TextAtom | ElementAtom | ComponentAtom;
+interface ComponentView {
+    atom: Atom;
+    host: NativeNode;
+    isParent: boolean;
+    rootHost: NativeNode;
+}
+
+/**
+ * Viewfly 配置项
+ */
+interface Config {
+    /** 根节点 */
+    root: JSXNode;
+    /** 平台渲染器 */
+    nativeRenderer: NativeRenderer;
+    /** 应用的上下文 */
+    context?: Injector;
+    /** 是否自动更新视图 */
+    autoUpdate?: boolean;
+}
+interface Application<T extends NativeNode = NativeNode> {
+    provide(providers: Provider | Provider[]): Application<T>;
+    mount(host: T): Application<T>;
+    use(module: Module | Module[]): Application<T>;
+    render(): Application<T>;
+    destroy(): void;
+}
+interface Module {
+    setup?(app: Application): void;
+    onAfterStartup?(app: Application): void;
+    onDestroy?(): void;
+}
+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 ComponentAnnotation, type ComponentInstance, type ComponentSetup, type ComponentView, type Config, type ConstructorProvider, DynamicRef, 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, createDerived, createDynamicRef, createRef, createRenderer, createSignal, forwardRef, getCurrentInstance, inject, jsx, jsxs, makeError, normalizeProvider, onMounted, onPropsChanged, onUnmounted, onUpdated, viewfly, watch, withAnnotation, withMemo };