@viewfly/core 0.0.19 → 0.0.20

package/bundles/di/_api.d.ts

@@ -0,0 +1,10 @@
+export * from './forward-ref';
+export * from './injectable';
+export * from './injection-token';
+export * from './injector';
+export * from './metadata';
+export * from './null-injector';
+export * from './provider';
+export * from './reflective-injector';
+export * from './reflective-provider';
+export * from './type';

package/bundles/di/forward-ref.d.ts

@@ -0,0 +1,10 @@
+export declare class ForwardRef<T = any> {
+    private forwardRefFn;
+    constructor(forwardRefFn: () => T);
+    getRef(): T;
+}
+/**
+ * 引用后声明的类的工具函数
+ * @param fn
+ */
+export declare function forwardRef<T>(fn: () => T): ForwardRef<T>;

package/bundles/di/injectable.d.ts

@@ -0,0 +1,20 @@
+export declare class Scope {
+    name: string;
+    constructor(name: string);
+    toString(): string;
+}
+export type ProvideScope = 'root' | Scope;
+export interface InjectableOptions {
+    provideIn: ProvideScope;
+}
+export interface Injectable {
+    provideIn?: ProvideScope;
+}
+export interface InjectableDecorator {
+    (options?: InjectableOptions): ClassDecorator;
+    new (options?: InjectableOptions): Injectable;
+}
+/**
+ * 可注入类的装饰器
+ */
+export declare const Injectable: InjectableDecorator;

package/bundles/di/injection-token.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 生成自定义依赖注入 token 的类
+ */
+export declare class InjectionToken<T> {
+    readonly description: string;
+    constructor(description: string);
+    toString(): string;
+}

package/bundles/di/injector.d.ts

@@ -0,0 +1,22 @@
+import { AbstractType, Type } from './type';
+import { InjectionToken } from './injection-token';
+/**
+ * 查找规则
+ */
+export declare enum InjectFlags {
+    /** 默认查找规则 */
+    Default = "Default",
+    /** 锁定当前容器 */
+    Self = "Self",
+    /** 跳过当前容器 */
+    SkipSelf = "SkipSelf",
+    /** 可选查找 */
+    Optional = "Optional"
+}
+/**
+ * DI 容器抽象基类
+ */
+export declare abstract class Injector {
+    abstract parentInjector: Injector | null;
+    abstract get<T>(token: Type<T> | AbstractType<T> | InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+}

package/bundles/di/metadata.d.ts

@@ -0,0 +1,43 @@
+import { AbstractType, Type } from './type';
+import { InjectFlags } from './injector';
+import { InjectionToken } from './injection-token';
+import { ForwardRef } from './forward-ref';
+export interface Inject {
+    token: InjectionToken<any> | Type<any> | ForwardRef<InjectionToken<any> | Type<any>>;
+}
+export 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;
+}
+/**
+ * 构造函数参数装饰器，用于改变注入 token
+ */
+export declare const Inject: InjectDecorator;
+export interface Self {
+}
+export interface SelfDecorator {
+    (): ParameterDecorator;
+    new (): Self;
+}
+export declare const Self: SelfDecorator;
+export interface SkipSelf {
+}
+export interface SkipSelfDecorator {
+    (): ParameterDecorator;
+    new (): SkipSelf;
+}
+export declare const SkipSelf: SkipSelfDecorator;
+export interface Optional {
+}
+export interface OptionalDecorator {
+    (): ParameterDecorator;
+    new (): Optional;
+}
+export declare const Optional: OptionalDecorator;
+export interface Prop {
+}
+export interface PropDecorator {
+    <T>(token?: Type<T> | AbstractType<T> | InjectionToken<T> | ForwardRef<T>, notFoundValue?: T, flags?: InjectFlags): PropertyDecorator;
+    new (token: any): Prop;
+}
+export declare const Prop: PropDecorator;

package/bundles/di/null-injector.d.ts

@@ -0,0 +1,6 @@
+import { Injector } from './injector';
+export declare const THROW_IF_NOT_FOUND: any;
+export declare class NullInjector extends Injector {
+    parentInjector: null;
+    get(token: any, notFoundValue?: any): any;
+}

package/bundles/di/provider.d.ts

@@ -0,0 +1,30 @@
+import { AbstractType, Type } from './type';
+import { InjectionToken } from './injection-token';
+export interface ClassProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useClass: Type<T>;
+    deps?: any[];
+}
+export interface FactoryProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useFactory: (...args: any[]) => T;
+    deps?: any[];
+}
+export interface ValueProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useValue: T;
+}
+export interface ExistingProvider<T = any> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+    useExisting: T;
+}
+export interface ConstructorProvider<T = any> {
+    provide: Type<T>;
+    deps?: [];
+}
+export interface TypeProvider<T = any> extends Type<T> {
+}
+export interface AbstractProvider<T = any> extends AbstractType<T> {
+}
+export type StaticProvider<T = any> = ClassProvider<T> | FactoryProvider<T> | ValueProvider<T> | ExistingProvider<T> | ConstructorProvider<T>;
+export type Provider<T = any> = TypeProvider<T> | AbstractProvider<T> | StaticProvider<T>;

package/bundles/di/reflective-injector.d.ts

@@ -0,0 +1,32 @@
+import { Provider } from './provider';
+import { InjectFlags, Injector } from './injector';
+import { NormalizedProvider } from './reflective-provider';
+import { AbstractType, Type } from './type';
+import { InjectionToken } from './injection-token';
+import { Scope } from './injectable';
+/**
+ * 反射注入器
+ */
+export declare class ReflectiveInjector extends Injector {
+    parentInjector: Injector | null;
+    protected staticProviders: Provider[];
+    protected scope?: Scope | undefined;
+    protected normalizedProviders: NormalizedProvider[];
+    protected recordValues: Map<InjectionToken<any> | Type<any> | AbstractType<any>, any>;
+    constructor(parentInjector: Injector | null, staticProviders: Provider[], scope?: Scope | undefined);
+    /**
+     * 用于获取当前注入器上下文内的实例、对象或数据
+     * @param token 访问 token
+     * @param notFoundValue 如未查找到的返回值
+     * @param flags 查询规则
+     */
+    get<T>(token: Type<T> | AbstractType<T> | InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    private getValue;
+    /**
+     * 解决并获取依赖参数
+     * @param deps 依赖规则
+     * @param notFoundValue 未查找到时的返回值
+     * @private
+     */
+    private resolveDeps;
+}

package/bundles/di/reflective-provider.d.ts

@@ -0,0 +1,20 @@
+import { Provider } from './provider';
+import { Injector } from './injector';
+import { Self, SkipSelf } from './metadata';
+import { ProvideScope } from './injectable';
+export interface ReflectiveDependency {
+    injectKey: any;
+    visibility: SkipSelf | Self | null;
+    optional: boolean;
+}
+export interface NormalizedProvider {
+    provide: any;
+    generateFactory: (injector: Injector, cacheFn: (token: any, value: any) => void) => (...args: any[]) => any;
+    deps: ReflectiveDependency[];
+    scope: ProvideScope | null;
+}
+/**
+ * 标准化 provide，并返回统一数据结构
+ * @param provider
+ */
+export declare function normalizeProvider(provider: Provider): NormalizedProvider;

package/bundles/di/type.d.ts

@@ -0,0 +1,7 @@
+export declare const Type: FunctionConstructor;
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+export interface AbstractType<T> extends Function {
+    prototype: T;
+}

package/bundles/di/utils/_api.d.ts

@@ -0,0 +1,3 @@
+export * from './annotations';
+export * from './decorators';
+export * from './stringify';

package/bundles/di/utils/annotations.d.ts

@@ -0,0 +1,33 @@
+import { Injector } from '../injector';
+export interface ClassAnnotation {
+    paramTypes: any[];
+    metadata: any;
+}
+export interface ParamAnnotation {
+    propertyKey: string | symbol;
+    parameterIndex: number;
+    metadata: any;
+}
+export interface PropertyDecoratorContextCallback {
+    (instance: any, propertyName: string | symbol, token: any, injector: Injector): void;
+}
+export interface PropertyAnnotation {
+    injectToken: any;
+    propertyKey: string | symbol;
+    contextCallback: PropertyDecoratorContextCallback;
+}
+/**
+ * 用于保存 class 的元数据
+ */
+export declare class Annotations {
+    private classes;
+    private props;
+    private params;
+    setClassMetadata(token: any, params: ClassAnnotation): void;
+    getClassMetadata(token: any): ClassAnnotation | undefined;
+    pushParamMetadata(token: any, params: ParamAnnotation): void;
+    getParamMetadata(token: any): ParamAnnotation[] | undefined;
+    getPropMetadataKeys(): any[];
+    pushPropMetadata(token: any, params: PropertyAnnotation): void;
+    getPropMetadata(token: any): PropertyAnnotation[] | undefined;
+}

package/bundles/di/utils/decorators.d.ts

@@ -0,0 +1,17 @@
+import { Annotations, PropertyDecoratorContextCallback } from './annotations';
+/**
+ * 创建参数装饰器的工厂函数
+ */
+export declare function makeParamDecorator(token: any, metadata: any): ParameterDecorator;
+/**
+ * 创建属性装饰器的工厂函数
+ */
+export declare function makePropertyDecorator(token: any, injectToken: any, contextCallback: PropertyDecoratorContextCallback): PropertyDecorator;
+/**
+ * 创建类装饰器的工厂函数
+ */
+export declare function makeClassDecorator(token: any, metadata: any): ClassDecorator;
+/**
+ * 获取类注解的工具函数
+ */
+export declare function getAnnotations(target: any): Annotations;

package/bundles/di/utils/stringify.d.ts

@@ -0,0 +1 @@
+export declare function stringify(token: any): string;

package/bundles/foundation/_api.d.ts

@@ -1,2 +1,7 @@
+export * from './component';
+export * from './jsx-element';
+export * from './memo';
+export * from './root.component';
+export * from './types';
 export * from './injection-tokens';
 export * from './renderer';

package/bundles/foundation/_utils.d.ts

@@ -1,3 +1,7 @@
+export interface ListenDelegate {
+    delegate: () => any;
+    listenFn: ((...args: any[]) => any) | void;
+}
 export interface ObjectChanges {
     remove: [string, any][];
     add: [string, any][];

package/bundles/{model → foundation}/component.d.ts

@@ -1,4 +1,4 @@
-import { AbstractType, InjectFlags, InjectionToken, Injector, Provider, ReflectiveInjector, Type } from '@tanbo/di';
+import { AbstractType, InjectFlags, InjectionToken, Injector, Provider, ReflectiveInjector, Type } from '../di/_api';
 import { JSXTypeof, Key, Props } from './jsx-element';
 import { JSXInternal } from './types';
 export declare class JSXComponent {

package/bundles/{model → foundation}/jsx-element.d.ts

@@ -1,5 +1,6 @@
 import { JSXComponent } from './component';
 import { JSXInternal } from './types';
+import { ListenDelegate } from './_utils';
 export interface Props {
     children?: JSXInternal.JSXNode | JSXInternal.JSXNode[];
     [key: string]: any;
@@ -20,10 +21,6 @@ export declare class JSXText implements JSXTypeof {
     constructor(text: string);
     is(target: JSXTypeof): boolean;
 }
-export interface ListenDelegate {
-    delegate: () => any;
-    listenFn: ((...args: any[]) => any) | void;
-}
 export declare class JSXElement implements JSXTypeof {
     type: string;
     props: Props;

package/bundles/foundation/renderer.d.ts

@@ -1,5 +1,5 @@
-import { RootComponent } from '../model/_api';
 import { NativeNode, NativeRenderer } from './injection-tokens';
+import { RootComponent } from './root.component';
 export declare abstract class RootComponentRef {
     abstract component: RootComponent;
 }

package/bundles/{model → foundation}/root.component.d.ts

@@ -1,11 +1,11 @@
-import { Subject } from '@tanbo/stream';
 import { Component } from './component';
 import { JSXInternal } from './types';
+import { Injector } from '../di/_api';
 /**
  * Viewfly 根组件，用于实现组件状态更新事件通知
  */
 export declare class RootComponent extends Component {
-    changeEmitter: Subject<void>;
-    constructor(factory: JSXInternal.ElementClass, parentInjector: any);
+    onChange: (() => void) | null;
+    constructor(factory: JSXInternal.ElementClass, parentInjector: Injector);
     markAsChanged(): void;
 }

package/bundles/{model → foundation}/types.d.ts

@@ -1,4 +1,5 @@
-import { Key, ExtractInstanceType, Ref } from './_api';
+import { Key } from './jsx-element';
+import { ExtractInstanceType, Ref } from './component';
 export type JSXNode = JSXInternal.JSXNode;
 export declare namespace JSXInternal {
     type ClassNames = string | Record<string, unknown> | ClassNames[];