@zeus-js/runtime-dom 0.0.2

package/dist/runtime-dom.d.ts

@@ -0,0 +1,225 @@
+type JSXPrimitive = string | number | boolean | null | undefined;
+export type JSXValue = JSXPrimitive | Node | JSXValue[];
+export type JSXGetter = () => JSXValue;
+export type Component<P extends Record<string, unknown> = Record<string, unknown>> = (props: P) => JSXValue;
+export type TemplateFactory<T extends Node = Node> = () => T;
+export type AttrValue = string | number | boolean | null | undefined;
+export type ClassValue = string | null | undefined | false | Record<string, boolean | null | undefined> | Array<ClassValue>;
+export type StyleValue = string | null | undefined | Partial<CSSStyleDeclaration> | Record<string, string | number | null | undefined>;
+export type RefTarget<T> = ((value: T | null) => void) | {
+    value: T | null;
+} | {
+    current: T | null;
+};
+
+import type { TemplateFactory } from './types';
+export declare function template<T extends Node = Node>(html: string, _isImportNode?: boolean, _isSVG?: boolean, _isMathML?: boolean): TemplateFactory<T>;
+
+import type { JSXValue } from './types';
+export type ContextId = symbol;
+export interface Context<T = unknown> {
+    readonly id: ContextId;
+    /**
+     * The default value passed to createContext().
+     *
+     * Note:
+     * - `defaultValue` itself may be `undefined`.
+     * - Use `hasDefaultValue` to check whether a default value was provided.
+     */
+    readonly defaultValue: T | undefined;
+    readonly hasDefaultValue: boolean;
+    readonly Provider: ContextProvider<T>;
+    readonly Bridge: ContextBridge<T>;
+}
+export interface ContextProviderProps<T> {
+    value: T;
+    children?: JSXValue | (() => JSXValue);
+    /**
+     * When true, creates a DOM context boundary for native custom elements /
+     * Web Components that live outside the Zeus owner tree.
+     */
+    bridge?: boolean;
+}
+export interface ContextBridgeProps<T> {
+    value: T;
+    children?: JSXValue | (() => JSXValue);
+}
+type ContextProvider<T> = (props: ContextProviderProps<T>) => JSXValue;
+type ContextBridge<T> = (props: ContextBridgeProps<T>) => JSXValue;
+export interface Owner {
+    parent?: Owner;
+    provides: Map<ContextId, unknown>;
+}
+export declare function getCurrentOwner(): Owner | undefined;
+export declare function createOwner(parent?: Owner | undefined): Owner;
+export declare function runWithOwner<T>(owner: Owner | undefined, fn: () => T): T;
+export declare function createContext<T>(): Context<T>;
+export declare function createContext<T>(defaultValue: T): Context<T>;
+export declare function provide<T>(context: Context<T>, value: T): void;
+export declare function inject<T>(context: Context<T>): T;
+export declare function inject<T>(context: Context<T>, fallback: T): T;
+export declare function useContext<T>(context: Context<T>): T;
+export declare function useContext<T>(context: Context<T>, fallback: T): T;
+export declare const ZEUS_CONTEXT_REQUEST = "zeus:context-request";
+export interface ZeusContextRequestDetail<T = unknown> {
+    id: ContextId;
+    resolved: boolean;
+    value?: T;
+    resolve: (value: T) => void;
+}
+export type ZeusContextRequestEvent<T = unknown> = CustomEvent<ZeusContextRequestDetail<T>>;
+export interface DOMContextResolution<T> {
+    found: boolean;
+    value: T | undefined;
+}
+/**
+ * Creates a transparent DOM element that acts as a context boundary.
+ * Native custom elements inside it can use `requestDOMContext` to receive
+ * context values via the DOM event protocol.
+ */
+export declare function createDOMContextBoundary<T>(context: Context<T>, value: T, children: JSXValue): Element;
+/**
+ * Registers a context value on a DOM target so that any descendant custom
+ * element can pick it up via `requestDOMContext`.
+ */
+export declare function provideDOMContext<T>(target: EventTarget, context: Context<T>, value: T): void;
+/**
+ * Internal precise DOM context resolver.
+ *
+ * Unlike requestDOMContext(), this can distinguish:
+ * - found: false, value: undefined
+ * - found: true, value: undefined
+ */
+export declare function resolveDOMContext<T>(host: HTMLElement, context: Context<T>): DOMContextResolution<T>;
+/**
+ * Public compatibility API.
+ *
+ * Returns the resolved value if found, otherwise undefined.
+ * If you need to distinguish "not found" from "found undefined",
+ * use resolveDOMContext().
+ */
+export declare function requestDOMContext<T>(host: HTMLElement, context: Context<T>): T | undefined;
+
+import { createOwner } from './context';
+import type { JSXValue } from './types';
+export interface RenderOptions {
+    owner?: ReturnType<typeof createOwner>;
+}
+export declare function render(value: JSXValue | (() => JSXValue), container: Element | DocumentFragment, options?: RenderOptions): () => void;
+
+import type { JSXValue } from './types';
+declare class DynamicRange {
+    private readonly parent;
+    private readonly marker;
+    private nodes;
+    constructor(parent: Node, marker: Node | null);
+    replace(value: JSXValue): void;
+    clear(): void;
+    current(): readonly Node[];
+}
+declare function insertTracked(parent: Node, value: JSXValue, marker: Node | null): Node[];
+export declare function removeNodes(nodes: readonly Node[]): void;
+declare function moveRangeBefore(nodes: readonly Node[], parent: Node, marker: Node | null): void;
+declare function firstNode(nodes: readonly Node[]): Node | null;
+declare function lastNode(nodes: readonly Node[]): Node | null;
+
+import { insertTracked } from './range';
+import type { JSXValue } from './types';export declare function insert(parent: Node, value: JSXValue, marker?: Node | null): void;
+export declare function mountDynamic(parent: Node, marker: Node, value: () => JSXValue): void;
+
+export declare function marker(parent: ParentNode, index: number): Comment;
+export declare function child(parent: ParentNode, index: number): ChildNode;
+declare function removeNodes$1(nodes: readonly Node[]): void;
+
+import type { AttrValue, ClassValue, JSXValue, StyleValue } from './types';
+export declare function bindText(node: Text, value: () => JSXValue): void;
+export declare function bindTextContent(el: Node, value: () => JSXValue): void;
+export declare function setAttr(el: Element, name: string, value: AttrValue): void;
+export declare function bindAttr(el: Element, name: string, value: () => AttrValue): void;
+export declare function bindProp<T extends Element, K extends keyof T>(el: T, name: K, value: () => T[K]): void;
+export declare function bindClass(el: Element, value: () => ClassValue): void;
+export declare function normalizeClass(value: ClassValue): string;
+export declare function bindStyle(el: HTMLElement | SVGElement, value: () => StyleValue): void;
+
+export declare function bindEvent(el: Element, name: string, handler: EventListener): void;
+export declare function delegateEvents(events: readonly string[]): void;
+declare function resetDelegatedEvents(): void;
+
+import type { RefTarget } from './types';
+export declare function setRef<T>(target: RefTarget<T> | null | undefined, value: T | null): void;
+export declare function bindRef<T extends Element>(el: T, target: RefTarget<T> | null | undefined): void;
+
+import type { JSXValue } from './types';
+export declare function createComponent<P extends Record<string, unknown>, R extends JSXValue>(component: (props: P) => R, props: P): R;
+
+import type { JSXValue } from './types';
+export type ShowProps = {
+    when: unknown;
+    fallback?: JSXValue | (() => JSXValue);
+    children?: JSXValue | (() => JSXValue);
+};
+export declare function Show(props: ShowProps): JSXValue;
+export declare function resolveValue(value: JSXValue | (() => JSXValue) | undefined): JSXValue;
+export declare function mountShow(parent: Node, marker: Node, when: () => unknown, children: () => JSXValue, fallback?: () => JSXValue): void;
+export type ForProps<T, K = unknown> = {
+    each: readonly T[] | null | undefined;
+    by?: (item: T, index: number) => K;
+    children: (item: T, index: number) => JSXValue;
+};
+export declare function For<T, K = unknown>(props: ForProps<T, K>): JSXValue;
+export declare function mountFor<T, K = unknown>(parent: Node, marker: Node, each: () => readonly T[] | null | undefined, key: ((item: T, index: number) => K) | undefined, render: (item: T, index: number) => JSXValue): void;
+
+import type { Context } from './context';
+import type { JSXValue } from './types';
+export type ElementPropConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ObjectConstructor | ArrayConstructor;
+export type PropDefinition<T = unknown> = ElementPropConstructor | {
+    type?: ElementPropConstructor;
+    attr?: string | false;
+    reflect?: boolean;
+    default?: T | (() => T);
+};
+export type PropOptions<P extends Record<string, unknown>> = Partial<{
+    [K in keyof P]: PropDefinition<P[K]>;
+}>;
+export interface DefineElementOptions<P extends Record<string, unknown>> {
+    shadow?: boolean | ShadowRootInit;
+    props?: PropOptions<P>;
+    styles?: string | string[];
+    consumes?: Context<any>[];
+}
+export interface DefineElementContext<E extends HTMLElement = HTMLElement> {
+    host: E;
+    emit: (name: string, detail?: unknown, options?: CustomEventInit) => boolean;
+}
+export type DefineElementSetup<P extends Record<string, unknown>, E extends HTMLElement = HTMLElement> = (props: Readonly<P>, context: DefineElementContext<E>) => JSXValue;
+export declare function defineElement<P extends Record<string, unknown> = Record<string, unknown>, E extends HTMLElement = HTMLElement>(tagName: string, options: DefineElementOptions<P>, setup: DefineElementSetup<P, E>): CustomElementConstructor;
+
+import type { JSXValue } from './types';
+export interface HostProps {
+    children?: JSXValue | (() => JSXValue);
+}
+export interface SlotProps {
+    name?: string;
+    children?: JSXValue | (() => JSXValue);
+}
+export declare function Host(props: HostProps): JSXValue;
+export declare function Slot(props: SlotProps): JSXValue;
+
+import type { JSXValue } from './types';
+export declare function createSlot(name?: string, fallback?: () => JSXValue): JSXValue;
+
+export type HostRenderMode = 'light' | 'shadow';
+export interface HostRenderContext {
+    host: HTMLElement;
+    mode: HostRenderMode;
+    lightChildren: readonly Node[];
+}
+export declare function getCurrentHostContext(): HostRenderContext | undefined;
+export declare function withHostContext<T>(context: HostRenderContext | undefined, fn: () => T): T;
+export declare function captureCurrentHostContext(): HostRenderContext | undefined;
+export declare function withCapturedHostContext<T extends (...args: never[]) => unknown>(fn: T): T;
+
+import './types';
+
+
+