@geektech/tsone 0.0.1 → 0.1.0

package/README.md

@@ -1,28 +1,44 @@
 # TSone
 
-轻量级纯 TypeScript 前端框架，提供响应式系统、类组件、策略化渲染和路由能力。
+English | [简体中文](./README-zh.md)
 
-## 特性
+A lightweight frontend framework written entirely in TypeScript, with
+reactivity, class-based components, strategy-driven rendering, and routing.
 
-- 纯 TypeScript 实现，公开 API 提供类型定义
-- Bun 原生工具链：安装、测试、构建、示例服务和文档服务均由 Bun 驱动
-- 响应式系统：`reactive`、`effect`、`computed`
-- 面向对象组件模型：`Component<Props, State>`、生命周期、事件、插槽
-- 策略模式渲染层：文本、元素、组件、插槽按 VNode 类型分发
-- 内置路由：`createRouter`、`RouterView`、`RouterLink`
-- 轻量级运行时，生产包无外部运行时依赖
+## Features
 
-## 安装
+- TypeScript-first implementation with typed public APIs
+- Bun-native tooling for installation, testing, builds, playgrounds, and docs
+- Documentation backed by a TypeScript typed-content registry
+- Reactive primitives: `reactive`, `effect`, and `computed`
+- Object-oriented components with `Component<Props, State>`, lifecycle hooks,
+  events, and slots
+- Strategy-based rendering that dispatches text, elements, components, and
+  slots by VNode type
+- Built-in routing with `createRouter`, `RouterView`, and `RouterLink`
+- Lightweight runtime with no external production dependencies
+
+## Repository Structure
+
+This repository is a Bun workspace monorepo with two published packages:
+`packages/tsone/` contains the browser framework `@geektech/tsone`, and
+`packages/tsone-cli/` contains the Bun-native development tooling
+`@geektech/tsone-cli`. Standalone example projects live in the root
+`playground/` directory.
+
+## Installation
 
 ```bash
-bun add @geektech/tsone
+bun add @geektech/tsone @geektech/tsone-cli
 ```
 
 ```bash
-pnpm add @geektech/tsone
+pnpm add @geektech/tsone @geektech/tsone-cli
 ```
 
-## 快速开始
+The framework and CLI require Bun `>=1.3.0` for the documented workflow.
+
+## Quick Start
 
 ```typescript
 import {
@@ -42,7 +58,7 @@ class App extends Component<Record<string, never>, AppState> {
   protected initState(): AppState {
     return {
       count: 0,
-      version: '0.0.1',
+      version: '0.0.2',
     };
   }
 
@@ -72,13 +88,73 @@ class App extends Component<Record<string, never>, AppState> {
 const state = reactive({ ready: true });
 const status = computed(() => (state.ready ? 'ready' : 'pending'));
 
-const app = createApp({ root: App, rootElement: '#app', state });
+const app = createApp({ root: App, state });
 app.mount();
 
 console.log(status.value);
 ```
 
-## 路由
+`createApp` uses `#app` as its default mount target, so an application can call
+`app.mount()` immediately after creation. If the target is not currently in the
+document, `mount()` safely skips that attempt. Pass `rootElement` only when you
+need to override the default target.
+
+## Development Tooling
+
+The separate `@geektech/tsone-cli` package provides `tsone dev` and
+`tsone build`. Its default entry is `src/main.ts`; that module must expose the
+application as `export const app`, and the value must provide
+`renderHtmlDocument()`.
+
+Create an optional `tsone.config.ts` at the project root:
+
+The config file supports only a plain-object default export; functional or
+function-valued config is not supported.
+
+```typescript
+import { defineConfig } from '@geektech/tsone-cli';
+
+export default defineConfig({
+  server: {
+    proxy: {
+      '/api': {
+        target: 'http://localhost:3000',
+        changeOrigin: true,
+        rewrite: (path) => path.replace(/^\/api/, ''),
+      },
+    },
+  },
+  build: { outDir: 'dist' },
+});
+```
+
+The string proxy shorthand is also supported, for example
+`{ '/backend': 'http://localhost:4000' }`. Defaults are `src/main.ts`,
+`127.0.0.1`, port `52211`, an empty `server.proxy`, and `dist`.
+
+```text
+tsone dev [--host <host>] [--port <port>]
+tsone build [--out-dir <path>]
+```
+
+`dev` accepts host/port overrides and `build` accepts the output-directory
+override; both `--port 3000` and `--port=3000` forms are valid. Build output
+must remain a safe child directory inside the project root.
+
+Programmatic tooling is imported from `@geektech/tsone-cli`, not from the
+framework root. It exports `defineConfig`, `resolveConfig`, `startDevServer`,
+and `build`. The dev server is owned by the caller, which must call
+`server.stop()`; `build()` returns absolute `root` and `outDir` values plus
+`assetsBuilt`.
+
+The development server serves HTTP only. Proxy targets may use HTTP or HTTPS.
+Rules use literal prefix matching with the longest match first, retain
+query/body/end-to-end headers, optionally apply `changeOrigin` and `rewrite`,
+and return `502 Bad Gateway` when the upstream is unreachable. CLI v1 has no
+config plugins, WebSocket, HMR, SSR, functional config, `public/` copying, or
+public minify/sourcemap settings.
+
+## Routing
 
 ```typescript
 import { Component, VNode, createApp } from '@geektech/tsone';
@@ -97,11 +173,11 @@ class Layout extends Component {
       children: [
         {
           component: RouterLink,
-          props: { to: '/', children: ['首页'] },
+          props: { to: '/', children: ['Home'] },
         },
         {
           component: RouterLink,
-          props: { to: '/users/42', children: ['用户'] },
+          props: { to: '/users/42', children: ['User'] },
         },
         { component: RouterView },
       ],
@@ -113,14 +189,18 @@ const router = createRouter({
   mode: 'history',
   routes: [
     { path: '/', component: HomePage },
-    { path: '/users/:id', component: UserPage, meta: { title: '用户详情' } },
+    {
+      path: '/users/:id',
+      component: UserPage,
+      meta: { title: 'User Details' },
+    },
   ],
 });
 
-createApp({ root: Layout, rootElement: '#app' }).use(router).mount();
+createApp({ root: Layout }).use(router).mount();
 ```
 
-## 开发命令
+## Development Commands
 
 ```bash
 bun install
@@ -128,23 +208,197 @@ bun test
 bun run build
 bun run dev
 bun run docs
+bun run docs:build
+```
+
+The root `playground/` directory contains two standalone projects:
+
+```bash
+bun run dev
+bun run dev:site
+bun run dev:admin
+```
+
+- `playground/official-site`: product website example
+- `playground/admin-dashboard`: admin dashboard example
+
+Documentation content is maintained in the typed-content registry. Chinese
+content lives in `packages/tsone/docs/app/content/zh/`, while English content
+lives in `packages/tsone/docs/app/content/en/`. Every logical route must exist
+in both directories.
+
+Chinese and English catalogs each contain exactly 14 logical routes. Add or
+remove a route in both catalogs in the same change.
+
+Content links stay locale-neutral: never write `/en/` manually. Chinese public
+routes are unprefixed, while English routes use `/en/`. Browser-language
+detection runs only at `/`; manual selection takes precedence and persists for
+later visits.
+
+Build the static documentation site with:
+
+```bash
+bun run docs:build
+```
+
+The build fails strictly for missing, extra, duplicate, empty, or
+mixed-language pages.
+
+The base HTML document shell can also be generated from `createApp`. It emits a
+`#app` mount node by default; pass `rootElement` only to use a different target.
+When a custom `body` is needed, pass a component or VNode rather than an HTML
+string. This API renders the mount node through TSone's renderer. In a Bun or
+Node static-generation environment, provide a DOM-like document first:
+
+```typescript
+import { createApp, type StyleSheet } from '@geektech/tsone';
+
+const styles: StyleSheet = [
+  {
+    selector: '.app',
+    properties: { maxWidth: '72rem' },
+  },
+];
+
+const app = createApp({
+  root: App,
+  document: {
+    lang: 'en',
+    title: 'TSone App',
+    styles,
+  },
+});
+
+const html = app.renderHtmlDocument({
+  scripts: [{ type: 'module', src: '/assets/app.js' }],
+});
 ```
 
-## 公开 API
+## Public API
 
-主入口 `@geektech/tsone`：
+The main `@geektech/tsone` entry point exports:
 
 - `createApp(options)`
+- `createApp({ root, rootProps })`
 - `Component<Props, State>`
+- `TransitionGroup` / `TransitionGroupProps` / `TransitionAnimationType`
 - `VNode`
-- `h()` / `createComponent()` / `slot()`
+- `h()` / `createComponent()` / `slot()` / `each()`
+- `Tag(tag, options)` for arbitrary HTML elements
+- `Div()` / `Span()` / `P()` / `Button()` / `Input()`
+- `Section()` / `Main()` / `Header()` / `Footer()` / `Nav()` / `Article()` /
+  `Aside()`
+- `H1()` through `H6()` / `Strong()` / `Em()` / `Small()` / `Pre()` /
+  `Code()` / `Blockquote()`
+- `Ul()` / `Ol()` / `Li()` / `A()` / `Img()`
+- `Form()` / `Label()` / `Textarea()` / `Select()` / `Option()`
+- `Table()` / `Thead()` / `Tbody()` / `Tr()` / `Th()` / `Td()`
+- `Directions` / `ModelBinding`
+- `InjectionKey` and component/application `provide()` / `inject()`
+- `createForm()` / `required()` / `minLength()` / `validate()`
+- `createApp(options).renderHtmlDocument(options)`
+- `renderHtmlDocument(options)`
+- `StyleSheet` / `renderStyleSheet(styles)`
 - `reactive()` / `readonly()`
 - `effect()` / `stop()`
 - `computed()`
 - `ref()` / `isRef()` / `unref()`
-- `version`，当前为 `0.0.1`
+- `version`, currently `0.0.2`
+
+## Rendering, Communication, and Forms
+
+`directions.if` controls whether an element, component, or slot is mounted. The
+node is unmounted when the condition is false:
+
+```typescript
+{
+  component: ProfilePanel,
+  directions: { if: this.state.visible },
+}
+```
+
+`each()` creates stable keys for list items so the renderer can reuse nodes
+during reordering, insertion, and removal:
+
+```typescript
+const items = each(
+  this.state.users,
+  (user) => ({ tag: 'li', children: [user.name] }),
+  (user) => user.id
+);
+```
+
+`TransitionGroup` animates the enter and exit of direct keyed children:
+
+```typescript
+{
+  component: TransitionGroup,
+  props: { tag: 'ul', type: 'fade', duration: 300 },
+  children: each(
+    this.state.items,
+    (item) => Li({ children: [item.label] }),
+    (item) => item.id
+  ),
+}
+```
+
+The animation types are `fade`, `slide-up`, `slide-down`, `slide-left`,
+`slide-right`, and `scale`. The defaults are a `div` wrapper, `fade`, and
+`300` ms with `ease` easing. Every direct child must have a unique key. Initial
+children animate in, and removed children stay mounted until their exit ends.
+TSone automatically disables these animations for
+`prefers-reduced-motion: reduce` or when Web Animations is unavailable.
+Reordering reuses and moves existing nodes without a reorder or FLIP animation.
+
+Component events return an unsubscribe function, while component VNodes can
+declare parent listeners through `emitters`:
+
+```typescript
+const stopListening = child.on('saved', (payload) => console.log(payload));
+stopListening();
+// { component: Editor, emitters: { saved: (payload) => this.save(payload) } }
+```
+
+Dependency injection resolves values from the current component, then its
+parents, and finally the application instance:
+
+```typescript
+const THEME: InjectionKey<{ mode: string }> = Symbol('theme');
+app.provide(THEME, { mode: 'dark' });
+const theme = this.inject(THEME, { mode: 'light' });
+```
+
+`directions.model` supports dot-separated paths and conversion functions.
+Native input, textarea, checkbox, radio, and select controls stay synchronized:
+
+```typescript
+Input({
+  props: { type: 'number' },
+  directions: {
+    model: {
+      path: 'profile.age',
+      parse: (value) => Number(value),
+      format: (value) => String(value ?? ''),
+    },
+  },
+});
+```
+
+Validation uses pure functions and does not own error UI or submission:
+
+```typescript
+const form = createForm(this.state, {
+  'profile.name': [required('Name is required'), minLength(2)],
+  'profile.age': [
+    validate((value) => Number(value) >= 18 || 'Age must be at least 18'),
+  ],
+});
+
+const result = form.validate();
+form.resetErrors();
+```
 
-路由入口 `@geektech/tsone/router`：
+The `@geektech/tsone/router` entry point exports:
 
 - `createRouter({ routes, mode, base })`
 - `Router`
@@ -154,23 +408,25 @@ bun run docs
 - `RouteRecord`
 - `RouteLocation`
 
-样式入口 `@geektech/tsone/style`：
+The `@geektech/tsone/style` entry point exports:
 
 - `StyleManager`
+- `StyleSheet` / `renderStyleSheet(styles)`
 
-## 发布前检查
+## Pre-Publish Checklist
 
 ```bash
 bun test
 bunx tsc --noEmit
 bun run build
-bun pm pack --dry-run
+bun pm pack --cwd packages/tsone --dry-run
 ```
 
-## 贡献
+## Contributing
 
-欢迎提交 Issue 和 Pull Request。开源发布前请确保测试、类型检查和构建均通过。
+Issues and pull requests are welcome. Before publishing an open-source release,
+make sure the tests, type checks, and build all pass.
 
-## 许可证
+## License
 
 [MIT](LICENSE)

package/dist/core/animation/TransitionGroup.d.ts

@@ -0,0 +1,7 @@
+import { Component } from '../component';
+import { type TransitionGroupNode, type TransitionGroupProps } from './types';
+export declare class TransitionGroup extends Component<TransitionGroupProps> {
+    protected initState(): object;
+    protected initStyles(): void;
+    protected render(): TransitionGroupNode;
+}

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

@@ -0,0 +1,2 @@
+export { TransitionGroup } from './TransitionGroup';
+export type { TransitionAnimationType, TransitionGroupProps } from './types';

package/dist/core/animation/list-animation-controller.d.ts

@@ -0,0 +1,16 @@
+import type { TransitionGroupOptions } from './types';
+export interface ListAnimationRun {
+    animation: Animation;
+    token: symbol;
+    keyframes: Keyframe[];
+    options: KeyframeAnimationOptions;
+    finished: Promise<'finished' | 'cancelled'>;
+}
+export declare class ListAnimationController {
+    private readonly runs;
+    playEnter(element: HTMLElement, options: TransitionGroupOptions): ListAnimationRun | null;
+    playExit(element: HTMLElement, options: TransitionGroupOptions): ListAnimationRun | null;
+    cancel(element: HTMLElement): void;
+    private play;
+    private canAnimate;
+}

package/dist/core/animation/transition-group-strategy.d.ts

@@ -0,0 +1,15 @@
+import { ElementRenderStrategy } from '../renderer/element-strategy';
+import type { RenderRuntimeContext, Renderable } from '../renderer/types';
+import { type TransitionGroupNode } from './types';
+export declare class TransitionGroupRenderStrategy extends ElementRenderStrategy<TransitionGroupNode> {
+    private readonly entries;
+    private readonly animations;
+    matches(vnode: Renderable): vnode is TransitionGroupNode;
+    protected mountChildren(element: HTMLElement, groupVNode: TransitionGroupNode, context: RenderRuntimeContext): void;
+    protected updateChildren(element: HTMLElement, _oldVNode: TransitionGroupNode, newVNode: TransitionGroupNode, context: RenderRuntimeContext): void;
+    protected unmountChildren(element: HTMLElement, vnode: TransitionGroupNode, context: RenderRuntimeContext): void;
+    private playEnter;
+    private startExit;
+    private finishExit;
+    private placeActiveEntries;
+}

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

@@ -0,0 +1,25 @@
+import { type EventListeners, type HTMLNode, type HTMLProps, type VNode } from '../vnode';
+export declare const TRANSITION_ANIMATION_TYPES: readonly ["fade", "slide-up", "slide-down", "slide-left", "slide-right", "scale"];
+export type TransitionAnimationType = (typeof TRANSITION_ANIMATION_TYPES)[number];
+export interface TransitionGroupOptions {
+    type: TransitionAnimationType;
+    duration: number;
+}
+export interface TransitionGroupProps {
+    tag?: string;
+    type?: TransitionAnimationType;
+    duration?: number;
+    elementProps?: HTMLProps;
+    listeners?: EventListeners;
+    children?: VNode[];
+}
+export interface TransitionGroupNode extends HTMLNode {
+    transitionGroup: TransitionGroupOptions;
+    children?: VNode[];
+}
+export type KeyedTransitionChild = VNode & {
+    key: string | number;
+};
+export declare function normalizeTransitionGroupProps(props: TransitionGroupProps): Required<Pick<TransitionGroupProps, 'tag' | 'type' | 'duration'>>;
+export declare function validateTransitionGroupChildren(children: Array<VNode | string>): KeyedTransitionChild[];
+export declare function isTransitionGroupNode(vnode: unknown): vnode is TransitionGroupNode;

package/dist/core/app.d.ts

@@ -1,4 +1,5 @@
-import { ComponentConstructor } from './component';
+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;
@@ -6,15 +7,23 @@ export interface Plugin {
     onUpdated?: (app: OneApp) => void;
     onBeforeUnmount?: (app: OneApp) => void;
 }
-export interface AppOptions<TState = Record<string, unknown>, TConfig = Record<string, unknown>> {
+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;
-    /** 应用挂载点 */
+    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;
@@ -22,17 +31,18 @@ export interface AppContext<TConfig = Record<string, unknown>> {
     config: TConfig;
     router?: Router;
 }
-export declare class OneApp<TState extends object = Record<string, unknown>, TConfig extends object = Record<string, unknown>> {
+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>);
+    constructor(options?: AppOptions<TState, TConfig, TRootProps>);
     private handleError;
     /**
      * 渲染错误UI
@@ -57,7 +67,7 @@ export declare class OneApp<TState extends object = Record<string, unknown>, TCo
     /**
      * 更新根组件
      */
-    updateRootComponent(component: ComponentConstructor): void;
+    updateRootComponent(component: ComponentConstructor<TRootProps>): void;
     /**
      * 更新应用状态
      */
@@ -66,6 +76,10 @@ export declare class OneApp<TState extends object = Record<string, unknown>, TCo
      * 获取应用上下文
      */
     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>;
     /**
      * 获取应用状态
      */
@@ -78,10 +92,18 @@ export declare class OneApp<TState extends object = Record<string, unknown>, TCo
      * 监听应用卸载
      */
     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;
@@ -89,4 +111,4 @@ export declare class OneApp<TState extends object = Record<string, unknown>, TCo
 /**
  * 创建应用实例
  */
-export declare function createApp<TState extends object = Record<string, unknown>, TConfig extends object = Record<string, unknown>>(options?: AppOptions<TState, TConfig>): OneApp<TState, TConfig>;
+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

@@ -4,6 +4,13 @@ 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 {
@@ -14,8 +21,11 @@ export declare abstract class Component<TProps extends ComponentProps = Componen
     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;
@@ -30,6 +40,12 @@ export declare abstract class Component<TProps extends ComponentProps = Componen
     setProps(props: Partial<TProps>): void;
     setState(state: Partial<TState>): void;
     setAppContext(context: unknown): void;
+    setParentComponent(parent: ComponentInstance | null): void;
+    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;
@@ -40,7 +56,7 @@ export declare abstract class Component<TProps extends ComponentProps = Componen
     protected getContext(): unknown;
     protected get router(): unknown;
     protected emit(eventName: string, ...args: unknown[]): void;
-    on(eventName: string, listener: ComponentEventListener): void;
+    on(eventName: string, listener: ComponentEventListener): () => void;
     off(eventName: string, listener: ComponentEventListener): void;
     private createRenderContext;
     private collectSlots;
@@ -49,5 +65,6 @@ export declare abstract class Component<TProps extends ComponentProps = Componen
     private trackStateProperties;
     private getRouterFrom;
     private getRouterFromGlobalApp;
+    private resolveAppInjection;
     private trackReactiveValue;
 }

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

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

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;