transone 0.1.0

package/README.md

@@ -0,0 +1,17 @@
+# @geektech/transone
+
+TransOne 核心框架包：一份 TypeScript 源码，跨端框架的核心运行时模型。
+
+- 响应式系统：`reactive`、`readonly`、`effect`、`stop`、`computed`、`ref`、`watch`
+- 面向对象组件：`Component<Props, State>`、生命周期、事件、插槽
+- 策略化渲染：`RenderStrategy` 按 VNode 类型分发（文本 / 元素 / 组件 / 插槽）
+- 内置路由：`createRouter`、`RouterView`、`RouterLink`
+- 样式管理：`StyleManager`
+
+与 TSone 同源：核心公开 API 复用 TSone，Web 产物可直接复用 TSone 渲染策略。
+编译器见 [@geektech/transone-cli](../transone-cli)。
+
+```bash
+bun test          # 测试
+bun run build     # 构建 dist（ESM + .d.ts）
+```

package/dist/core/app.d.ts

@@ -0,0 +1,114 @@
+import { ComponentConstructor, ComponentProps, InjectionKey, InjectionResult } from './component';
+import { type HtmlDocumentBody, type HtmlDocumentOptions } from './document';
+import type { Router } from '../router';
+export interface Plugin {
+    install: (app: OneApp, ...args: unknown[]) => void;
+    onMounted?: (app: OneApp) => void;
+    onUpdated?: (app: OneApp) => void;
+    onBeforeUnmount?: (app: OneApp) => void;
+}
+export type AppDocumentOptions = Partial<Omit<HtmlDocumentOptions, 'body'>> & {
+    body?: HtmlDocumentBody;
+};
+export type AppDocumentRenderOptions = AppDocumentOptions;
+export interface AppOptions<TState = Record<string, unknown>, TConfig = Record<string, unknown>, TRootProps extends ComponentProps = ComponentProps> {
+    /** 根组件构造函数 */
+    root?: ComponentConstructor<TRootProps>;
+    /** 根组件 props */
+    rootProps?: TRootProps;
+    /** 应用挂载点，默认 #app */
+    rootElement?: string | Element;
+    /** 全局状态 */
+    state?: TState;
+    /** 全局配置 */
+    config?: TConfig;
+    /** HTML 文档壳配置，用于 dev/build 生成入口页面 */
+    document?: AppDocumentOptions;
+}
+export interface AppContext<TConfig = Record<string, unknown>> {
+    app: OneApp;
+    version: string;
+    config: TConfig;
+    router?: Router;
+}
+export declare class OneApp<TState extends object = Record<string, unknown>, TConfig extends object = Record<string, unknown>, TRootProps extends ComponentProps = ComponentProps> {
+    private options;
+    private container;
+    private rootInstance;
+    private mounted;
+    private templateEngine;
+    private readonly appContext;
+    private readonly providers;
+    private plugins;
+    private unmountedCallback?;
+    router?: Router;
+    constructor(options?: AppOptions<TState, TConfig, TRootProps>);
+    private handleError;
+    /**
+     * 渲染错误UI
+     */
+    private renderErrorUI;
+    /**
+     * 使用插件
+     */
+    use(plugin: Plugin, ...args: unknown[]): this;
+    /**
+     * 挂载应用
+     */
+    mount(): void;
+    /**
+     * 卸载应用
+     */
+    unmount(): void;
+    /**
+     * 应用是否正在运行
+     */
+    isRunning(): boolean;
+    /**
+     * 更新根组件
+     */
+    updateRootComponent(component: ComponentConstructor<TRootProps>): void;
+    /**
+     * 更新应用状态
+     */
+    update(state?: Partial<TState>): this;
+    /**
+     * 获取应用上下文
+     */
+    getContext(): AppContext<TConfig>;
+    provide<T>(key: InjectionKey<T>, value: T): this;
+    inject<T>(key: InjectionKey<T>): T | undefined;
+    inject<T>(key: InjectionKey<T>, fallback: T): T;
+    resolveInjection<T>(key: InjectionKey<T>): InjectionResult<T>;
+    /**
+     * 获取应用状态
+     */
+    getState(): TState | undefined;
+    /**
+     * 设置应用状态
+     */
+    setState(newState: TState): this;
+    /**
+     * 监听应用卸载
+     */
+    onUnmounted(callback: () => void): this;
+    /**
+     * 生成应用入口 HTML 文档
+     */
+    renderHtmlDocument(options?: AppDocumentRenderOptions): string;
+    /**
+     * 解析根元素
+     */
+    private resolveRootElement;
+    private resolveMountContainer;
+    private createMountDocumentBody;
+    private createMountElementFromSelector;
+    private mergeDocumentScripts;
+    private onMounted;
+    private onUpdated;
+    private onBeforeUnmount;
+}
+/**
+ * 创建应用实例
+ */
+export declare function createApp<TState extends object = Record<string, unknown>, TConfig extends object = Record<string, unknown>, TRootProps extends ComponentProps = ComponentProps>(options?: AppOptions<TState, TConfig, TRootProps>): OneApp<TState, TConfig, TRootProps>;

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

@@ -0,0 +1,79 @@
+import { StyleManager } from '../../style/StyleManager';
+import { ComponentInstance } from '../renderer';
+import type { VNode } from '../vnode';
+export type ComponentProps = object;
+export type ComponentState = object;
+export type ComponentEventListener = (...args: unknown[]) => void;
+export type InjectionKey<T> = (string | symbol) & {
+    readonly __injectionType?: T;
+};
+export interface InjectionResult<T> {
+    found: boolean;
+    value: T | undefined;
+}
+export type ComponentConstructor<TProps extends ComponentProps = ComponentProps, TState extends ComponentState = ComponentState> = new (props?: TProps) => Component<TProps, TState>;
+export type AnyComponentConstructor = new (props?: never) => Component<ComponentProps, ComponentState>;
+export declare abstract class Component<TProps extends ComponentProps = ComponentProps, TState extends ComponentState = ComponentState> implements ComponentInstance {
+    protected props: TProps;
+    private vnode;
+    private el;
+    private readonly renderer;
+    private readonly templateEngine;
+    private readonly childComponents;
+    private readonly eventListeners;
+    private readonly providers;
+    private readonly updateEffect;
+    private appContext;
+    private parentComponent;
+    private elementChangeListener;
+    protected styleManager: StyleManager;
+    state: TState;
+    mounted: boolean;
+    constructor(props?: TProps);
+    protected abstract initState(): TState;
+    protected abstract initStyles(): void;
+    protected abstract render(): VNode;
+    mount(container: HTMLElement): void;
+    mountToNode(): Node;
+    update(): void;
+    unmount(): void;
+    setProps(props: Partial<TProps>): void;
+    setState(state: Partial<TState>): void;
+    setAppContext(context: unknown): void;
+    setParentComponent(parent: ComponentInstance | null): void;
+    getParentComponent(): ComponentInstance | null;
+    setElementChangeListener(listener: (previousElement: Node, nextElement: Node) => void): void;
+    provide<T>(key: InjectionKey<T>, value: T): void;
+    inject<T>(key: InjectionKey<T>): T | undefined;
+    inject<T>(key: InjectionKey<T>, fallback: T): T;
+    resolveInjection<T>(key: InjectionKey<T>): InjectionResult<T>;
+    getElement(): Node | null;
+    protected beforeMount(): void;
+    protected onMounted(): void;
+    protected beforeUpdate(): void;
+    protected onUpdated(): void;
+    protected beforeUnmount(): void;
+    protected onUnmounted(): void;
+    /**
+     * 错误边界钩子：后代组件渲染或更新抛错时被调用。
+     * 返回 false 表示错误已被处理并停止继续向上传播；
+     * 返回 true 或 undefined 时错误继续冒泡到更外层边界。
+     */
+    protected onErrorCaptured?(error: unknown, instance: ComponentInstance): boolean | void;
+    /**
+     * 沿组件父链寻找最近的错误边界。返回 true 表示错误已被边界处理。
+     */
+    private dispatchError;
+    protected getContext(): unknown;
+    protected get router(): unknown;
+    protected emit(eventName: string, ...args: unknown[]): void;
+    on(eventName: string, listener: ComponentEventListener): () => void;
+    off(eventName: string, listener: ComponentEventListener): void;
+    private createRenderContext;
+    private collectSlots;
+    private getSlotName;
+    private normalizeSlotChild;
+    private getRouterFrom;
+    private getRouterFromGlobalApp;
+    private resolveAppInjection;
+}

package/dist/core/component/index.d.ts

@@ -0,0 +1,4 @@
+import { Component } from './base';
+import type { AnyComponentConstructor, ComponentConstructor, ComponentEventListener, InjectionKey, InjectionResult, ComponentProps, ComponentState } from './base';
+export { Component };
+export type { AnyComponentConstructor, ComponentConstructor, ComponentEventListener, InjectionKey, InjectionResult, ComponentProps, ComponentState, };

package/dist/core/component.d.ts

@@ -0,0 +1 @@
+export * from './component/index';

package/dist/core/document.d.ts

@@ -0,0 +1,32 @@
+import type { Renderable } from './renderer/types';
+import { type StyleSheet } from '../style/sheet';
+export { renderStyleSheet, type StyleAtRule, type StyleProperties, type StyleRule, type StyleSheet, type StyleSheetEntry, type StyleValue, } from '../style/sheet';
+export type HtmlAttributeValue = string | number | boolean | null | undefined;
+export type HtmlAttributes = Record<string, HtmlAttributeValue>;
+export type HtmlDocumentBody = Renderable | Renderable[];
+export interface HtmlHeadElement {
+    tag: string;
+    attributes?: HtmlAttributes;
+    text?: string;
+}
+export interface HtmlScript {
+    src: string;
+    type?: string;
+    async?: boolean;
+    defer?: boolean;
+    attributes?: HtmlAttributes;
+}
+export interface HtmlDocumentOptions {
+    title: string;
+    body: HtmlDocumentBody;
+    lang?: string;
+    charset?: string;
+    viewport?: string;
+    description?: string;
+    htmlAttributes?: HtmlAttributes;
+    bodyAttributes?: HtmlAttributes;
+    head?: HtmlHeadElement[];
+    styles?: StyleSheet;
+    scripts?: HtmlScript[];
+}
+export declare function renderHtmlDocument(options: HtmlDocumentOptions): string;

package/dist/core/form.d.ts

@@ -0,0 +1,24 @@
+export type ValidationResult = boolean | string;
+export type ValidationRule<T = unknown> = (value: T, model: object) => ValidationResult;
+export type ValidationRules<TModel extends object> = {
+    [TPath in keyof TModel & string]?: readonly ValidationRule[];
+} & Record<string, readonly ValidationRule[] | undefined>;
+export interface FieldValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface FormValidationResult {
+    valid: boolean;
+    errors: Record<string, string[]>;
+}
+export interface FormController<TModel extends object> {
+    readonly model: TModel;
+    readonly errors: Record<string, string[]>;
+    validate(): FormValidationResult;
+    validateField(path: string): FieldValidationResult;
+    resetErrors(): void;
+}
+export declare function required(message?: string): ValidationRule;
+export declare function minLength(length: number, message?: string): ValidationRule;
+export declare function validate(rule: ValidationRule): ValidationRule;
+export declare function createForm<TModel extends object>(model: TModel, rules: ValidationRules<TModel>): FormController<TModel>;

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+export * from './app';
+export * from './component';
+export * from './reactive';
+export * from './vnode';
+export * from './template';
+export * from './renderer';
+export * from './document';
+export * from './model';
+export * from './form';

package/dist/core/model.d.ts

@@ -0,0 +1,18 @@
+export interface ModelBindingOptions {
+    path: string;
+    parse?: (value: unknown) => unknown;
+    format?: (value: unknown) => string;
+}
+export type ModelBinding = string | ModelBindingOptions;
+type ModelState = Record<string, unknown>;
+export declare function modelPath(binding: ModelBinding): string;
+export declare function getModelValue(state: ModelState, path: string): unknown;
+export declare function setModelValue(state: ModelState, path: string, value: unknown): void;
+export declare class ModelBindingController {
+    private readonly bindings;
+    bind(element: HTMLElement, binding: ModelBinding, state: ModelState): void;
+    cleanup(element: HTMLElement): void;
+    private isSupportedControl;
+    private sameBinding;
+}
+export {};

package/dist/core/reactive/scheduler.d.ts

@@ -0,0 +1,32 @@
+import type { ReactiveEffect } from './types';
+/**
+ * 响应式 effect 批处理调度器。
+ *
+ * 同一批同步状态变更（同一个任务内的多次 mutation）只会触发一次 effect
+ * 运行：effect 被 enqueue 后去重入队，并在微任务中统一冲刷（flush）。
+ * 冲刷期间的重复入队会在同一轮循环中继续处理，直到队列清空。
+ *
+ * 组件渲染通过该调度器合并更新：连续修改 state 不会逐次重渲染，
+ * 与 Vue 微任务调度 / React 自动批处理的语义一致。
+ */
+export declare class ReactiveScheduler {
+    private readonly pending;
+    private flushing;
+    private flushPromise;
+    private flushResolve;
+    /**
+     * 将 effect 加入待冲刷队列（去重）。
+     */
+    enqueue(effect: ReactiveEffect): void;
+    /**
+     * 同步冲刷队列：立即执行所有待运行的 effect。
+     * 若当前正处于一次冲刷中（例如在 effect 内部调用），则直接返回，
+     * 由正在进行的冲刷循环负责处理新增任务。
+     */
+    flush(): void;
+    /**
+     * 返回一个在待冲刷的 effect 全部执行完成后 resolve 的 Promise。
+     * 若当前没有待冲刷任务，立即 resolve。
+     */
+    nextTick(): Promise<void>;
+}

package/dist/core/reactive/types.d.ts

@@ -0,0 +1,24 @@
+export interface ReactiveEffect<T = unknown> {
+    (): T | undefined;
+    deps: Set<ReactiveEffect>[];
+    id: number;
+    active: boolean;
+    scheduler?: (effect: ReactiveEffect) => void;
+}
+export interface ReactiveEffectOptions {
+    lazy?: boolean;
+    scheduler?: (effect: ReactiveEffect) => void;
+    throwOnError?: boolean;
+}
+export interface ComputedRef<T> {
+    readonly value: T;
+}
+export declare const IS_REACTIVE: unique symbol;
+export declare const IS_READONLY: unique symbol;
+export declare const IS_REF: unique symbol;
+export interface Ref<T = unknown> {
+    value: T;
+}
+export declare const MUTATING_ARRAY_METHODS: readonly ["push", "pop", "shift", "unshift", "splice", "sort", "reverse"];
+export declare function hasReactiveFlag(value: object, flag: typeof IS_REACTIVE | typeof IS_READONLY): boolean;
+export declare function isObject(value: unknown): value is object;

package/dist/core/reactive.d.ts

@@ -0,0 +1,77 @@
+import { ComputedRef, Ref, ReactiveEffect, ReactiveEffectOptions } from './reactive/types';
+import { ReactiveScheduler } from './reactive/scheduler';
+export type { ComputedRef, Ref, ReactiveEffect, ReactiveEffectOptions, } from './reactive/types';
+export declare const reactiveScheduler: ReactiveScheduler;
+/**
+ * 等待当前批次的响应式 effect 全部执行完成（通常是组件重渲染）。
+ * 修改 state 后需要立即读取 DOM 时使用：await nextTick()。
+ */
+export declare function nextTick(): Promise<void>;
+/**
+ * 同步冲刷待执行的响应式 effect，立即完成组件重渲染。
+ * 一般仅测试或需要同步读 DOM 的场景使用。
+ */
+export declare function flushSync(): void;
+export declare class ReactiveSystem {
+    private static instance;
+    private activeEffect;
+    private readonly effectStack;
+    private targetMap;
+    private reactiveMap;
+    private readonlyMap;
+    /** 反向映射：响应式代理 -> 原始对象，供 toRawValue 反查 */
+    private proxyMap;
+    private constructor();
+    static getInstance(): ReactiveSystem;
+    reactive<T extends object>(target: T): T;
+    /**
+     * 将响应式代理反查为原始对象；非代理值原样返回。
+     * 用于数组 includes/indexOf/lastIndexOf 的对比，让用户传入
+     * 原始对象也能命中数组中的响应式元素。
+     */
+    private toRawValue;
+    /**
+     * 创建响应式数组
+     */
+    private createReactiveArray;
+    readonly<T extends object>(target: T): Readonly<T>;
+    effect<T = unknown>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffect<T>;
+    /**
+     * 在指定 effect 的上下文中运行 fn，使 fn 内的响应式访问被收集到该 effect，
+     * 而不是当前外层 effect。组件渲染用它隔离依赖：子组件在父组件渲染期间
+     * 执行自身 render 时，子 state 的访问不会污染父组件的 effect。
+     */
+    runWithEffect<T>(effect: ReactiveEffect, fn: () => T): T;
+    computed<T>(getter: () => T): ComputedRef<T>;
+    private cleanup;
+    private track;
+    private trigger;
+    stop(effect: ReactiveEffect): void;
+}
+export declare function reactive<T extends object>(target: T): T;
+export declare function readonly<T extends object>(target: T): Readonly<T>;
+export declare function effect<T = unknown>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffect<T>;
+export declare function computed<T>(getter: () => T): ComputedRef<T>;
+export declare function ref<T>(value: T): Ref<T>;
+export declare function isRef(value: unknown): value is Ref<unknown>;
+export declare function unref<T>(value: T | Ref<T>): T;
+export declare function stop(effect: ReactiveEffect): void;
+export interface WatchSource<T> {
+    value: T;
+}
+export type WatchCallback<T> = (value: T, oldValue: T | undefined, onCleanup: (cleanup: () => void) => void) => void;
+export interface WatchOptions {
+    /** 建立后立即执行一次回调（此时 oldValue 为 undefined） */
+    immediate?: boolean;
+    /** 深度追踪 getter 返回值的嵌套属性变化 */
+    deep?: boolean;
+    /** 变化发生时同步回调（默认随调度器批处理，同一批变化只回调一次） */
+    sync?: boolean;
+}
+/**
+ * 侦听响应式源（getter 或 ref）的变化并执行回调。
+ * 返回一个用于停止侦听的函数。
+ */
+export declare function watch<T>(source: WatchSource<T> | (() => T), callback: WatchCallback<T>, options?: WatchOptions): () => void;
+export declare function isReactive(value: unknown): boolean;
+export declare function isReadonly(value: unknown): boolean;

package/dist/core/renderer/element-strategy.d.ts

@@ -0,0 +1,32 @@
+import { HTMLNode } from '../vnode';
+import type { RenderRuntimeContext, RenderStrategy, Renderable } from './types';
+export declare const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+/**
+ * 仅包含 HTML 中不存在的 SVG 专属标签：这些标签必须通过
+ * createElementNS 创建，否则会落入 HTML 命名空间而无法渲染。
+ * 与 HTML 重名的标签（title/desc/a/image 等）不在此列，避免误伤。
+ */
+export declare const SVG_TAGS: ReadonlySet<string>;
+export declare class ElementRenderStrategy<TNode extends HTMLNode = HTMLNode> implements RenderStrategy<TNode> {
+    private readonly listeners;
+    private readonly effects;
+    private readonly modelBindings;
+    matches(vnode: Renderable): vnode is TNode;
+    mount(vnode: TNode, context: RenderRuntimeContext): Node;
+    patch(oldVNode: TNode, newVNode: TNode, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(vnode: TNode, currentNode: Node, context: RenderRuntimeContext): void;
+    protected mountChildren(element: Element, vnode: TNode, context: RenderRuntimeContext): void;
+    protected updateChildren(element: Element, oldVNode: TNode, newVNode: TNode, context: RenderRuntimeContext): void;
+    protected unmountChildren(element: Element, vnode: TNode, context: RenderRuntimeContext): void;
+    private applyProps;
+    private applyDirections;
+    private updateOrdinaryChildren;
+    private updateKeyedChildren;
+    private hasOnlyKeyedChildren;
+    private assertNoDuplicateKeys;
+    private getVNodeKey;
+    private collectListeners;
+    private updateListeners;
+    private setupReactiveAttribute;
+    private trackEffect;
+}

package/dist/core/renderer/props.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedEventName {
+    eventName: string;
+    modifiers: Set<string>;
+}
+export declare function isEventProp(key: string): boolean;
+export declare function eventNameFromProp(key: string): string;
+export declare function parseEventName(event: string): ParsedEventName;
+export declare function wrapEventHandler(handler: (event: Event) => void, modifiers: Set<string>): EventListener;
+export declare function setStyleValue(style: CSSStyleDeclaration, property: string, value: string | number): void;

package/dist/core/renderer/types.d.ts

@@ -0,0 +1,37 @@
+import type { TemplateEngine } from '../template';
+import type { ComponentEventListener, ComponentProps } from '../component';
+import type { InjectionKey, InjectionResult } from '../component';
+import type { VNode } from '../vnode';
+export interface ComponentInstance {
+    mountToNode(): Node;
+    update(): void;
+    unmount(): void;
+    setProps(props: Partial<ComponentProps>): void;
+    setAppContext?(context: unknown): void;
+    setParentComponent?(parent: ComponentInstance | null): void;
+    getParentComponent?(): ComponentInstance | null;
+    setElementChangeListener?(listener: (previousElement: Node, nextElement: Node) => void): void;
+    resolveInjection?<T>(key: InjectionKey<T>): InjectionResult<T>;
+    getElement(): Node | null;
+    on(eventName: string, listener: ComponentEventListener): () => void;
+}
+export type Renderable = VNode | string;
+export interface RendererHost {
+    mount(vnode: Renderable, context: RenderRuntimeContext): Node;
+    patch(oldVNode: Renderable, newVNode: Renderable, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(vnode: Renderable, currentNode: Node, context: RenderRuntimeContext): void;
+}
+export interface RenderRuntimeContext {
+    templateEngine: TemplateEngine;
+    appContext?: unknown;
+    renderer: RendererHost;
+    slots: Record<string, Array<VNode | string>>;
+    registerChild(component: ComponentInstance): void;
+    unregisterChild(component: ComponentInstance): void;
+}
+export interface RenderStrategy<T extends Renderable = Renderable> {
+    matches(vnode: Renderable): vnode is T;
+    mount(vnode: T, context: RenderRuntimeContext): Node;
+    patch(oldVNode: T, newVNode: T, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(vnode: T, currentNode: Node, context: RenderRuntimeContext): void;
+}

package/dist/core/renderer.d.ts

@@ -0,0 +1,43 @@
+import { ComponentNode, SlotProvider } from './vnode';
+export { ElementRenderStrategy } from './renderer/element-strategy';
+export type { ComponentInstance, RenderRuntimeContext, RenderStrategy, Renderable, RendererHost, } from './renderer/types';
+import type { RenderRuntimeContext, RenderStrategy, Renderable } from './renderer/types';
+export declare class RendererContext {
+    private readonly strategies;
+    constructor();
+    mount(vnode: Renderable, context: RenderRuntimeContext): Node;
+    patch(oldVNode: Renderable, newVNode: Renderable, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(vnode: Renderable, currentNode: Node, context: RenderRuntimeContext): void;
+    private findStrategy;
+}
+export declare class TextRenderStrategy implements RenderStrategy<string> {
+    matches(vnode: Renderable): vnode is string;
+    mount(vnode: string, context: RenderRuntimeContext): Node;
+    patch(oldVNode: string, newVNode: string, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(): void;
+}
+export declare class ComponentRenderStrategy implements RenderStrategy<ComponentNode> {
+    private readonly instances;
+    private readonly instanceNodes;
+    private readonly emitterUnsubscribers;
+    matches(vnode: Renderable): vnode is ComponentNode;
+    mount(vnode: ComponentNode, context: RenderRuntimeContext): Node;
+    patch(oldVNode: ComponentNode, newVNode: ComponentNode, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(_vnode: ComponentNode, currentNode: Node, context: RenderRuntimeContext): void;
+    private createProps;
+    private syncEmitters;
+    private clearEmitters;
+    private trackInstanceNode;
+    private clearInstanceNodes;
+}
+export declare class SlotRenderStrategy implements RenderStrategy<SlotProvider> {
+    private readonly renderedChildren;
+    matches(vnode: Renderable): vnode is SlotProvider;
+    mount(vnode: SlotProvider, context: RenderRuntimeContext): Node;
+    patch(oldVNode: SlotProvider, newVNode: SlotProvider, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(_vnode: SlotProvider, currentNode: Node, context: RenderRuntimeContext): void;
+    private resolveChildren;
+    private replaceSlotChildren;
+    private mountSlotChildren;
+    private unmountSlotChildren;
+}

package/dist/core/template.d.ts

@@ -0,0 +1,50 @@
+import { ReactiveEffect } from './reactive';
+export interface TemplateBinding {
+    node: Text;
+    originalText: string;
+    effect: ReactiveEffect;
+}
+export declare class TemplateEngine {
+    state: object;
+    private bindings;
+    private readonly templateRegex;
+    constructor(state: object);
+    /**
+     * 解析模板字符串，创建响应式的文本节点
+     * @param text 包含模板表达式的文本字符串
+     * @returns 创建的文本节点
+     */
+    parseTemplate(text: string): Text;
+    /**
+     * 设置响应式绑定
+     */
+    private setupReactiveBindings;
+    /**
+     * 计算模板文本的值
+     */
+    private evaluateTemplate;
+    /**
+     * 从状态对象中获取值，支持嵌套属性访问
+     */
+    private getValueFromState;
+    /**
+     * 清除所有模板绑定
+     */
+    clearBindings(): void;
+    /**
+     * 获取当前的绑定数量
+     */
+    getBindingCount(): number;
+    /**
+     * 检查模板是否包含表达式
+     */
+    hasExpressions(text: string): boolean;
+    /**
+     * 获取模板中的所有表达式键
+     */
+    extractKeys(text: string): string[];
+    /**
+     * 计算模板值
+     */
+    evaluateTemplateValue(text: string): string;
+}