@viewfly/core 2.0.0 → 2.2.0

package/README.md

@@ -1,6 +1,69 @@
-Viewfly
-================================
+# @viewfly/core
 
-Viewfly 是一个简单、数据驱动的前端框架。此项目为 Viewfly 的内核实现，要开发完整的应该的应用，还需要结合 `@viewfly/platform-browser` 包，才能在浏览器运行。
+Viewfly 的**内核包**：函数组件、JSX、响应式与信号、`watch`、生命周期、`inject` 与 IoC 相关 API、以及 **`withMark`** 等与 UI 逻辑直接相关的入口均由此包提供。
 
-完整文档请参考官方网站：[viewfly.org](https://viewfly.org)
+在浏览器里挂载应用请使用 **`@viewfly/platform-browser`** 的 **`createApp`**（其内部使用本包提供的应用模型）。
+
+---
+
+## 安装
+
+```bash
+pnpm add @viewfly/core
+# 或 npm / yarn
+```
+
+本包依赖 **`reflect-metadata`**。正常从 **`@viewfly/core`** 的主入口导入时，会随模块加载一并初始化；若你的打包拆包方式导致依赖注入相关运行时异常，可在应用入口**最先**增加显式导入：
+
+```ts
+import 'reflect-metadata'
+```
+
+更稳妥的做法以 [官网](https://viewfly.org) 与当前版本的说明为准。
+
+---
+
+## JSX / TSX 配置
+
+在 **`tsconfig.json`** 中启用 automatic JSX runtime，并把来源指向本包：
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@viewfly/core"
+  }
+}
+```
+
+使用 Babel 时，将 `@babel/preset-react` 的 `runtime: "automatic"` 与 `importSource: "@viewfly/core"` 对齐上述行为。
+
+---
+
+## 能力速览（面向使用者）
+
+以下为日常开发中最常见的方向，**具体类型与参数以类型定义和官网为准**。
+
+| 方向 | 公开 API 与用法提示 |
+|------|---------------------|
+| 组件 | 函数组件：在 JSX 中当标签使用；配合生命周期钩子使用。 |
+| 生命周期 | **`onMounted`**、**`onUpdated`**、**`onUnmounted`** 等（须在组件 setup 阶段调用）。 |
+| 响应式 | **`reactive`**、**`shallowReactive`**、**`watch`** 等（`reactive` 模块）。 |
+| 信号 | **`createSignal`**、**`createEffect`**、**`createDerived`** 等（`signals` 模块）。 |
+| 依赖注入 | 在组件内用 **`inject`** 解析 token；用 **`Injectable()`** 声明可注入类；用 **`withAnnotation`** 或 **`createContext`** / **`createContextProvider`** 挂载 **`Provider`**；根应用上通过 **`createApp(...).provide(...)`**（由 **`@viewfly/platform-browser`** 提供）注册全局提供者。 |
+| 自定义 DOM 属性标记 | **`withMark(marks, setup)`**：为组件渲染出的元素附加与 `marks` 同名的属性（常用于 scoped CSS 的 `scopeId` 等场景）。 |
+
+**说明**：源码中可能存在标有 **`@internal`** 或未在官网文档化的符号，它们仅供框架内部或实验用途，**不建议业务代码依赖**；升级版本时也可能在无 semver 预告的情况下变更。
+
+---
+
+## 文档与示例
+
+- **官方文档**：[viewfly.org](https://viewfly.org)
+- **本仓库试跑**：仓库根目录执行 `pnpm dev` 打开 playground
+
+---
+
+## License
+
+MIT

package/dist/_utils/make-error.d.ts

@@ -0,0 +1 @@
+export declare function makeError(name: string): (message: string) => Error;

package/dist/base/_api.d.ts

@@ -0,0 +1,13 @@
+export * from './component';
+export * from './context';
+export * from './dep';
+export * from './injection-tokens';
+export * from './jsx-element';
+export * from './lifecycle';
+export * from './memo';
+export * from './ref';
+export * from './renderer';
+export * from './root.component';
+export * from './types';
+export { comparePropsWithCallbacks } from './_utils';
+export type { Atom, ElementNamespace } from './_utils';

package/dist/base/_utils.d.ts

@@ -0,0 +1,46 @@
+import { Key, ViewFlyNode } from './jsx-element';
+import { NativeNode } from './injection-tokens';
+import { Component, ComponentSetup } from './component';
+export declare function hasChange(newProps: Record<string, any>, oldProps: Record<string, any>): boolean;
+export declare const refKey = "ref";
+export 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;
+export declare function classToString(config: unknown): string;
+export declare function styleToObject(style: string | Record<string, any>): Record<string, any>;
+export declare const TextAtomType: unique symbol;
+export declare const ElementAtomType: unique symbol;
+export declare const ComponentAtomType: unique symbol;
+export type ElementNamespace = string | void;
+export interface TextAtom {
+    type: typeof TextAtomType;
+    index: number;
+    jsxNode: string;
+    nodeType: string;
+    key?: null;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    namespace: ElementNamespace;
+}
+export interface ElementAtom {
+    type: typeof ElementAtomType;
+    index: number;
+    nodeType: string;
+    key?: Key;
+    jsxNode: ViewFlyNode<string>;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    namespace: ElementNamespace;
+}
+export interface ComponentAtom {
+    type: typeof ComponentAtomType;
+    index: number;
+    nodeType: ComponentSetup;
+    key?: Key;
+    jsxNode: ViewFlyNode<ComponentSetup> | Component;
+    nativeNode: NativeNode | null;
+    child: Atom | null;
+    sibling: Atom | null;
+    namespace: ElementNamespace;
+}
+export type Atom = TextAtom | ElementAtom | ComponentAtom;

package/dist/base/component.d.ts

@@ -0,0 +1,65 @@
+import { Key, Props } from './jsx-element';
+import { NativeNode } from './injection-tokens';
+import { JSX } from './types';
+import { LifeCycleCallback } from './lifecycle';
+import { ComponentAtom } from './_utils';
+export declare function getSetupContext(need?: boolean): Component;
+export type ClassNames = string | Record<string, unknown> | false | null | undefined | ClassNames[];
+export interface ComponentInstance<P> {
+    $portalHost?: NativeNode;
+    $render(): JSXNode;
+    $useMemo?(currentProps: P, prevProps: P): boolean;
+}
+export type JSXNode = JSX.Element | JSX.ElementClass | string | number | boolean | null | undefined | Iterable<JSXNode>;
+export interface ComponentSetup<P = any> {
+    (props: P): (() => JSXNode) | ComponentInstance<P>;
+}
+export interface ComponentViewMetadata {
+    atom: ComponentAtom;
+    host: NativeNode;
+    isParent: boolean;
+    rootHost: NativeNode;
+}
+/**
+ * Viewfly 组件管理类，用于管理组件的生命周期，上下文等
+ */
+export declare class Component {
+    readonly parentComponent: Component | null;
+    readonly type: ComponentSetup;
+    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;
+    updatedCallbacks?: LifeCycleCallback[] | null;
+    private updatedDestroyCallbacks?;
+    protected _dirty: boolean;
+    protected _changed: boolean;
+    private isFirstRendering;
+    private rawProps;
+    private refs;
+    private listener;
+    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;
+    updateProps(newProps: Record<string, any>): void;
+    canUpdate(oldProps: Record<string, any>, newProps: Record<string, any>): boolean;
+    rerender(): JSXNode;
+    destroy(): void;
+    rendered(): void;
+    private invokeMountHooks;
+    private invokeUpdatedHooks;
+}
+/**
+ * 获取当前组件实例
+ */
+export declare function getCurrentInstance(): Component;
+export declare function registryComponentDestroyCallback(fn: () => void): void;

package/dist/base/context.d.ts

@@ -0,0 +1,42 @@
+import { AbstractType, ClassProvider, ExistingProvider, ExtractValueType, FactoryProvider, InjectFlags, InjectionToken, Injector, Provider, Scope, Type, ValueProvider } from '../di/_api';
+import { Props } from './jsx-element';
+import { ComponentSetup } from './component';
+export declare function createContext(providers: Provider[], scope?: Scope | null, parentInjector?: Injector): (props: Props) => () => import('./component').JSXNode | import('./component').JSXNode[];
+export interface ContextProviderParams<T> {
+    provide: Type<T> | AbstractType<T> | InjectionToken<T>;
+}
+export interface ContextProvider<T> extends Props {
+    useClass?: ClassProvider<T>['useClass'];
+    useFactory?: FactoryProvider<T>['useFactory'];
+    useValue?: ValueProvider<T>['useValue'];
+    useExisting?: ExistingProvider<T>['useExisting'];
+}
+export declare function createContextProvider<T>(params: ContextProviderParams<T>): (props: ContextProvider<T>) => () => import('./jsx-element').ViewFlyNode<string | ComponentSetup<any>>;
+/**
+ * 通过组件上下文获取 IoC 容器内数据的勾子方法
+ */
+export declare function inject<T extends Type<any> | AbstractType<any> | InjectionToken<any>, U = never>(token: T, notFoundValue?: U, flags?: InjectFlags): ExtractValueType<T> | U;
+export 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>
+ *   }
+ * })
+ * ```
+ */
+export declare function withAnnotation<T extends ComponentSetup>(annotation: ComponentAnnotation, componentSetup: T): T;

package/dist/base/dep.d.ts

@@ -0,0 +1,9 @@
+export declare class Dep {
+    effect: () => void;
+    destroyCallbacks: Array<() => void>;
+    constructor(effect: () => void);
+    destroy(): void;
+}
+export declare function getDepContext(): Dep | undefined;
+export declare function pushDepContext(dep: Dep): void;
+export declare function popDepContext(): void;

package/dist/base/injection-tokens.d.ts

@@ -0,0 +1,20 @@
+import { ElementNamespace } from './_utils';
+export type NativeNode = Record<string, any>;
+export declare abstract class NativeRenderer<ElementNode = NativeNode, TextNode = NativeNode> {
+    abstract createElement(name: string, namespace: ElementNamespace): ElementNode;
+    abstract createTextNode(textContent: string, namespace: ElementNamespace): TextNode;
+    abstract setProperty(node: ElementNode, key: string, value: any, namespace: ElementNamespace): void;
+    abstract appendChild(parent: ElementNode, newChild: ElementNode | TextNode, namespace: ElementNamespace): void;
+    abstract prependChild(parent: ElementNode, newChild: ElementNode | TextNode, namespace: ElementNamespace): void;
+    abstract removeProperty(node: ElementNode, key: string, namespace: ElementNamespace): void;
+    abstract setStyle(target: ElementNode, key: string, value: any, namespace: ElementNamespace): void;
+    abstract removeStyle(target: ElementNode, key: string, namespace: ElementNamespace): void;
+    abstract setClass(target: ElementNode, value: string, namespace: ElementNamespace): void;
+    abstract listen<T = any>(node: ElementNode, type: string, callback: (ev: T) => any, namespace: ElementNamespace): void;
+    abstract unListen(node: ElementNode, type: string, callback: (ev: any) => any, namespace: ElementNamespace): void;
+    abstract remove(node: ElementNode | TextNode, namespace: ElementNamespace): void;
+    abstract cleanChildren(node: ElementNode, namespace: ElementNamespace): void;
+    abstract syncTextContent(target: TextNode, content: string, namespace: ElementNamespace): void;
+    abstract insertAfter(newNode: ElementNode | TextNode, ref: ElementNode | TextNode, namespace: ElementNamespace): void;
+    abstract getNameSpace(type: string, namespace: ElementNamespace): string | void;
+}

package/dist/base/jsx-element.d.ts

@@ -0,0 +1,64 @@
+import { ComponentSetup, JSXNode } from './component';
+import { NativeNode } from './injection-tokens';
+export interface Props {
+    children?: JSXNode | JSXNode[];
+}
+export declare function Fragment(props: Props): () => JSXNode | JSXNode[];
+export type Key = number | string;
+export declare function jsx(type: string | ComponentSetup, props: Props & Record<string, any>, key?: Key): ViewFlyNode;
+export declare const jsxs: typeof jsx;
+export interface ViewFlyNode<T = string | ComponentSetup> {
+    type: T;
+    props: Props & Record<string, any>;
+    key?: Key;
+}
+export declare const JSXNodeFactory: {
+    createNode<T = string | ComponentSetup<any>>(type: T, props: Props & Record<string, any>, key?: Key): ViewFlyNode<T>;
+};
+/**
+ * 给组件的视图元素节点添加自定义属性标记
+ * @param marks
+ * @param setup
+ * @example
+ * ```tsx
+ * const App = withMark('mark', function(props) {
+ *   return () => {
+ *     return <div>...</div>
+ *   }
+ * })
+ * ```
+ */
+export declare function withMark<T extends ComponentSetup>(marks: string | string[], setup: T): T;
+/**
+ * 内部使用
+ * @internal
+ * @param mark
+ * @param render
+ */
+export declare function applyMark(mark: string | string[], render: () => JSXNode): JSXNode;
+export interface PortalProps<T extends NativeNode> extends Props {
+    host: T;
+}
+/**
+ * 将子节点渲染到指定节点
+ * @param props
+ * @example
+ * ```tsx
+ * function App() {
+ *   const modal = document.getElementById('modal')!
+ *   return () => {
+ *     return (
+ *       <div>
+ *         <Portal host={modal}>
+ *           这里的内容将渲染到 modal 节点
+ *         </Portal>
+ *       </div>
+ *     )
+ *   }
+ * }
+ * ```
+ */
+export declare function Portal<T extends NativeNode>(props: PortalProps<T>): {
+    $portalHost: T;
+    $render(): JSXNode | JSXNode[];
+};

package/dist/base/lifecycle.d.ts

@@ -0,0 +1,37 @@
+export interface LifeCycleCallback {
+    (): void | (() => void);
+}
+/**
+ * 当组件第一次渲染完成时触发
+ * @param callback
+ * ```tsx
+ * function App() {
+ *   onMount(() => {
+ *     console.log('App mounted!')
+ *   })
+ *   return () => <div>...</div>
+ * }
+ * ```
+ */
+export 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>
+ * }
+ * ```
+ */
+export declare function onUpdated(callback: LifeCycleCallback): () => void;
+/**
+ * 当组件销毁时调用回调函数
+ * @param callback
+ */
+export declare function onUnmounted(callback: () => void): void;

package/dist/base/memo.d.ts

@@ -0,0 +1,8 @@
+import { Props } from './jsx-element';
+import { ComponentInstance, JSXNode } from './component';
+/**
+ * @deprecated 即将弃用，Viewfly 默认就有 memo 的效果
+ * @param canUseMemo
+ * @param render
+ */
+export declare function withMemo<T extends Props = Props>(canUseMemo: ComponentInstance<T>['$useMemo'], render: () => JSXNode): ComponentInstance<T>;

package/dist/base/ref.d.ts

@@ -0,0 +1,44 @@
+import { ComponentInstance } from './component';
+export interface RefListener<T> {
+    (current: T): void | (() => void);
+}
+export 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;
+export interface AbstractInstanceType<T extends Record<string, any>> {
+    (): T & ComponentInstance<any>;
+}
+export 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>
+ *   }
+ * }
+ * ```
+ */
+export declare function createDynamicRef<T, U = ExtractInstanceType<T>>(callback: RefListener<U>): DynamicRef<U>;
+export declare class StaticRef<T> extends DynamicRef<T> {
+    get current(): T | null;
+    private _current;
+    constructor();
+}
+export declare function createRef<T, U = ExtractInstanceType<T>>(): StaticRef<U>;

package/dist/base/renderer.d.ts

@@ -0,0 +1,4 @@
+import { NativeNode, NativeRenderer } from './injection-tokens';
+import { ElementNamespace } from './_utils';
+import { Component } from './component';
+export declare function createRenderer(component: Component, nativeRenderer: NativeRenderer, namespace: ElementNamespace): (host: NativeNode) => void;

package/dist/base/root.component.d.ts

@@ -0,0 +1,9 @@
+import { Component, ComponentSetup } from './component';
+/**
+ * Viewfly 根组件，用于实现组件状态更新事件通知
+ */
+export declare class RootComponent extends Component {
+    private refresh;
+    constructor(factory: ComponentSetup, refresh: () => void);
+    markAsChanged(changedComponent?: Component): void;
+}

package/dist/base/types.d.ts

@@ -0,0 +1,32 @@
+import { Key, ViewFlyNode } from './jsx-element';
+import { ComponentInstance, ComponentSetup } from './component';
+import { DynamicRef, ExtractInstanceType } from './ref';
+export 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 ElementAttributesProperty {
+        props: {};
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+    interface IntrinsicElements {
+        [name: string]: any;
+    }
+    interface IntrinsicClassAttributes<T> {
+        ref?: DynamicRef<T>;
+    }
+}

package/dist/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/dist/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/dist/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/dist/di/injection-token.d.ts

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

package/dist/di/injector.d.ts

@@ -0,0 +1,26 @@
+import { AbstractType, Type } from './type';
+import { InjectionToken } from './injection-token';
+/**
+ * 查找规则
+ */
+export declare enum InjectFlags {
+    /** 默认查找规则 */
+    Default = "Default",
+    /** 锁定当前容器 */
+    Self = "Self",
+    /** 跳过当前容器 */
+    SkipSelf = "SkipSelf",
+    /** 可选查找 */
+    Optional = "Optional"
+}
+/**
+ * 根据 token 推断返回数据类型
+ */
+export type ExtractValueType<T> = T extends Type<any> ? InstanceType<T> : T extends AbstractType<infer K> ? K : T extends InjectionToken<infer V> ? V : never;
+/**
+ * DI 容器抽象基类
+ */
+export 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;
+}

package/dist/di/metadata.d.ts

@@ -0,0 +1,43 @@
+import { AbstractType, Type } from './type';
+import { ExtractValueType, 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 extends Type<any> | AbstractType<any> | InjectionToken<any>, U = never>(token?: T | ForwardRef<ExtractValueType<T>>, notFoundValue?: U, flags?: InjectFlags): PropertyDecorator;
+    new (token: any): Prop;
+}
+export declare const Prop: PropDecorator;

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

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

package/dist/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>;