@viewfly/core 2.1.0 → 3.0.0-alpha.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,12 @@
+export * from './component';
+export * from './context';
+export * from './dep';
+export * from './injection-tokens';
+export * from './jsx-element';
+export * from './lifecycle';
+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,77 @@
+import { Key } 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 {
+    $portalHost?: NativeNode;
+    $render(): JSXNode;
+}
+export type JSXNode = JSX.Element | JSX.ElementClass | string | number | boolean | null | undefined | Iterable<JSXNode>;
+export interface ComponentSetup<P = any> {
+    (props: P): (() => JSXNode) | ComponentInstance;
+}
+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;
+    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 refEffects;
+    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;
+    rerender(): JSXNode;
+    destroy(): void;
+    rendered(): void;
+    private invokeMountHooks;
+    private invokeUpdatedHooks;
+}
+/**
+ * 获取当前组件实例
+ * @returns 当前组件实例
+ * @example
+ * ```tsx
+ * function App() {
+ *   const instance = getCurrentInstance()
+ *   console.log(instance)
+ *   return () => <div>...</div>
+ * }
+ * ```
+ */
+export declare function getCurrentInstance(): Component;
+/**
+ * 注册组件销毁回调函数
+ * @param fn 要注册的回调函数
+ * @internal
+ */
+export declare function registryComponentDestroyCallback(fn: () => void): void;

package/dist/base/context.d.ts

@@ -0,0 +1,112 @@
+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';
+/**
+ * 创建一个上下文，用于在组件之间共享数据
+ * @param providers 提供者，用于提供数据
+ * @param scope 作用域，用于限制提供者的作用域
+ * @param parentInjector 父注入器，用于自定义父注入器，默认从当前组件树中自动获取
+ * @returns 一个上下文组件，组件的子元素都可以通过 inject 获取到提供者提供的数据
+ * @example
+ * ```tsx
+ * @Injectable()
+ * class ExampleService {}
+ *
+ * function Child(props) {
+ *   const exampleService = inject(ExampleService)
+ *   console.log(exampleService)
+ *   return () => {
+ *     return <div>{props.children}</div>
+ *   }
+ * }
+ * function App() {
+ *   const Context = createContext([
+ *     ExampleService
+ *   ])
+ *   return () => {
+ *     return <Context>
+ *       <Child>test</Child>
+ *     </Context>
+ *   }
+ * }
+ * ```
+ */
+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'];
+}
+/**
+ * 创建一个上下文提供者组件，组件的子元素都可以通过 inject 获取到提供者提供的数据
+ * @param params 提供者参数
+ * @returns 一个上下文提供者组件，组件的子元素都可以通过 inject 获取到提供者提供的数据
+ * @example
+ * ```tsx
+ * const ExampleService = createContextProvider({
+ *   provide: ExampleService
+ * })
+ *
+ * function Child() {
+ *   const exampleService = inject(ExampleService)
+ *   console.log(exampleService)
+ *   return () => {
+ *     return <div>{exampleService.name}</div>
+ *   }
+ * }
+ *
+ * function App() {
+ *   const value = new ExampleService()
+ *   return () => {
+ *     return <ExampleService useValue={value}>
+ *       <Child/>
+ *     </ExampleService>
+ *   }
+ * }
+ */
+export declare function createContextProvider<T>(params: ContextProviderParams<T>): (props: ContextProvider<T>) => () => import('./jsx-element').ViewFlyNode<string | ComponentSetup<any>>;
+/**
+ * 通过组件上下文获取 IoC 容器内数据的勾子方法
+ * @param token 注入的 token
+ * @param notFoundValue 未找到时的值
+ * @param flags 注入标志
+ * @returns 注入的值
+ * @example
+ * ```tsx
+ * function ChildComponent() {
+ *   const exampleService = inject(ExampleService)
+ *   console.log(exampleService)
+ *   return () => {
+ *     return <div>{exampleService.name}</div>
+ *   }
+ * }
+ */
+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 = any;
+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,54 @@
+export interface LifeCycleCallback {
+    (): void | (() => void);
+}
+/**
+ * 当组件挂载后调用回调函数
+ * @param callback 回调函数
+ * @returns 一个函数，用于停止监听
+ * @example
+ * ```tsx
+ * function App() {
+ *   onMounted(() => {
+ *     console.log('App mounted!')
+ *     return () => {
+ *       console.log('destroy prev mount!')
+ *     }
+ *   })
+ *   return () => <div>...</div>
+ * }
+ * ```
+ */
+export declare function onMounted(callback: LifeCycleCallback): void;
+/**
+ * 当组件视图更新后调用回调函数
+ * @param callback 回调函数
+ * @returns 一个函数，用于停止监听
+ * @example
+ * ```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 回调函数
+ * @returns 一个函数，用于停止监听
+ * @example
+ * ```tsx
+ * function App() {
+ *   onUnmounted(() => {
+ *     console.log('App unmounted!')
+ *   })
+ *   return () => <div>...</div>
+ * }
+ * ```
+ */
+export declare function onUnmounted(callback: () => void): void;

package/dist/base/ref.d.ts

@@ -0,0 +1,50 @@
+import { ComponentInstance } from './component';
+import { RefProp } from './types';
+export type ExtractInstanceType<T, U = T extends (...args: any) => any ? ReturnType<T> : T> = U extends ComponentInstance ? Omit<U, keyof ComponentInstance> : U extends Function ? never : T;
+export interface DynamicRef<T> {
+    (value: T): void | (() => void);
+}
+/**
+ * 创建一个动态 ref，当 ref 的绑定的元素或组件初始化后，会调用副作用函数，并把元素或组件的实例作为参数传入。
+ * @param effect 用于接收实例的副作用函数，该函数还可以返回一个清理副作用的函数，当元素或组件销毁时调用
+ * @returns 一个函数，用于清理副作用
+ * @example
+ * ```tsx
+ * function App() {
+ *   const ref = createDynamicRef<HTMLDivElement>((node) => {
+ *     console.log(node)
+ *     return () => {
+ *       console.log('destroy')
+ *     }
+ *   })
+ *   return () => {
+ *     return <div ref={ref}>test</div>
+ *   }
+ * }
+ * ```
+ */
+export declare function createDynamicRef<T, U = ExtractInstanceType<T>>(effect: DynamicRef<U>): DynamicRef<U>;
+export type Ref<T> = {
+    readonly value: T;
+};
+/**
+ * 创建一个引用对象，并添加到 JSX 节点上属性上，当组件渲染后，即可通过 .value 获取到绑定节点的实例
+ * - 当绑定到虚拟 DOM 元素节点上时，value 为当前节点的 DOM 元素
+ * - 当绑定到组件节点上时，value 为组件函数返回的对象
+ * @example
+ * ```tsx
+ * function App() {
+ *   const ref = createRef<HTMLDivElement>()
+ *   onMounted(() => {
+ *      console.log(ref.value)
+ *   })
+ *   return () => {
+ *     return <div ref={ref}>...</div>
+ *   }
+ * }
+ * ```
+ */
+export declare function createRef<T, U = ExtractInstanceType<T> | null>(): Ref<U | null>;
+export type RefEffects = Map<RefProp<any>, (() => void) | void>;
+export declare function applyRefs(ref: RefProp<any> | RefProp<any>[], value: object, refEffects: RefEffects): void;
+export declare function updateRefs(ref: RefProp<any> | RefProp<any>[], value: object, refEffects: RefEffects): void;

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,29 @@
+import { Key, ViewFlyNode } from './jsx-element';
+import { ComponentInstance, ComponentSetup } from './component';
+import { DynamicRef, ExtractInstanceType, Ref } from './ref';
+export type RefProp<T> = Ref<ExtractInstanceType<T> | null> | DynamicRef<ExtractInstanceType<T>>;
+export declare namespace JSX {
+    type ElementType = keyof IntrinsicElements | ComponentSetup;
+    interface Element extends ViewFlyNode {
+    }
+    interface KeyedAttributes {
+        key?: Key;
+    }
+    interface IntrinsicAttributes extends KeyedAttributes {
+        ref?: any;
+    }
+    interface ElementClass extends ComponentInstance {
+    }
+    interface ElementAttributesProperty {
+        props: {};
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+    interface IntrinsicElements {
+        [name: string]: any;
+    }
+    interface IntrinsicClassAttributes<T> {
+        ref?: RefProp<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;
+}