svelte-tv 1.0.0 → 1.0.2

package/dist/__package_types_tmp__/core/elementNode.d.ts

@@ -0,0 +1,548 @@
+import { type BorderRadius, type BorderStyle, type StyleEffects, type AnimationSettings, type ElementText, type Styles, type AnimationEvents, type AnimationEventHandler, AddColorString, type OnEvent, NewOmit, SingleBorderStyle, type DollarString } from './intrinsicTypes.js';
+import States, { type NodeStates } from './states.js';
+import type { RendererMain, INode, INodeAnimateProps, IAnimationController, LinearGradientProps, RadialGradientProps, CoreShaderNode } from '@lightningjs/renderer';
+import { TextNode } from './nodeTypes.js';
+import { ForwardFocusHandler, FocusNode } from './focusManager.js';
+import { IRendererNode, IRendererShader, IRendererShaderProps, IRendererTextNode } from './dom-renderer/domRendererTypes.js';
+export declare function enqueueDelete(node: ElementNode, n: number): void;
+export declare function convertToShader(_node: ElementNode, v: StyleEffects): IRendererShader;
+declare global {
+    interface HTMLElement {
+        /** Assigned for development, to quickly get ElementNode from selected HTMLElement */
+        element?: ElementNode;
+    }
+}
+export type RendererNode = AddColorString<Partial<NewOmit<INode, 'parent' | 'shader' | 'src' | 'children' | 'id' | 'removeChild'>>>;
+export interface ElementNode extends RendererNode, FocusNode {
+    [key: string]: unknown;
+    /** @internal for managing series of insertions and deletions */
+    _queueDelete?: number;
+    _animationQueue?: Array<{
+        props: Partial<INodeAnimateProps<CoreShaderNode>>;
+        animationSettings?: AnimationSettings;
+    }> | undefined;
+    _animationQueueSettings?: AnimationSettings;
+    _animationRunning?: boolean;
+    _animationSettings?: AnimationSettings;
+    _autofocus?: any;
+    _containsFlexGrow?: boolean | null;
+    _deferAlphaUntilLayout?: number | undefined;
+    _hasRenderedChildren?: boolean;
+    _effects?: Record<string, any>;
+    _fontFamily?: string;
+    _id: string | undefined;
+    _parent: ElementNode | undefined;
+    _rendererProps?: any;
+    _states?: States;
+    _style?: Styles;
+    _stateStyleFallbacks?: Record<string, unknown>;
+    _stateStyleFallbackVersion?: number;
+    _theme?: Styles;
+    _transitionAnimations?: Record<string, IAnimationController | undefined>;
+    _transitionAnimationVersions?: Record<string, number | undefined>;
+    _lastAnyKeyPressTime?: number;
+    _type: 'element' | 'textNode';
+    _undoStyles?: string[];
+    _display?: 'flex' | 'block';
+    _onLayout?: (this: ElementNode, target: ElementNode) => void;
+    _requiresLayout: boolean;
+    autosize?: boolean;
+    /**
+     * Optional component name for inspector / dev tooling — emitted by the
+     * Babel devtools plugin (see `devtools/jsx-locator.js`).
+     */
+    componentName?: string;
+    /**
+     * Optional source-location string for inspector / dev tooling — emitted by
+     * the Babel devtools plugin.
+     */
+    componentLocation?: string;
+    /**
+     * The distance from the bottom edge of the parent element.
+     * When `bottom` is set, `mountY` is automatically set to 1.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    bottom?: number;
+    /**
+     * An array of child `ElementNode` or `ElementText` nodes.
+     */
+    children: Array<ElementNode | ElementText>;
+    /**
+     * Enable debug logging for this specific node.
+     */
+    debug?: boolean;
+    /**
+     * Specifies how much a flex item should grow relative to the rest of the flex items.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex-grow
+     */
+    flexGrow?: number;
+    /**
+     * Specifies whether flex items are forced onto one line or can wrap onto multiple lines.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    flexWrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    /**
+     * Determines if an element is a flex item. If set to `false`, the element will be ignored by the flexbox layout.
+     * @default false
+     */
+    flexItem?: boolean;
+    /**
+     * Specifies the order of a flex item relative to the rest of the flex items.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    flexOrder?: number;
+    /**
+     * Defines the ability for a flex item to shrink if necessary.
+     * Defaults to 0 since existing legacy implementations did not shrink layout boxes.
+     * Only available in NEW flex layout.
+     */
+    flexShrink?: number;
+    /**
+     * Defines the default size of an element before the remaining space is distributed.
+     * Only available in NEW flex layout.
+     */
+    flexBasis?: number | string;
+    /**
+     * Forwards focus to a child element. It can be a numeric index of the child or a handler function.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/focus?id=forwardfocus
+     */
+    forwardFocus?: number | ForwardFocusHandler;
+    /**
+     * If `true`, the states of this node will be propagated to its children.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/states?id=forwardstates
+     */
+    forwardStates?: boolean;
+    /**
+     * The underlying Lightning Renderer node object. This is where the properties are ultimately set for rendering.
+     */
+    lng: INode | IRendererNode | Partial<ElementNode> | (IRendererTextNode & {
+        shader?: any;
+    });
+    /**
+     * A boolean indicating whether the node has been rendered.
+     */
+    rendered: boolean;
+    /**
+     * The main renderer instance.
+     */
+    renderer?: RendererMain;
+    /**
+     * The distance from the right edge of the parent element.
+     * When `right` is set, `mountX` is automatically set to 1.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=layout-and-positioning-elements
+     */
+    right?: number;
+    /**
+     * The index of the currently selected child element, used for focus management for Column and Row components.
+     */
+    selected?: number;
+    /**
+     * The width of the element before flexbox layout is applied. Used internally for layout calculations.
+     */
+    preFlexwidth?: number;
+    /**
+     * The height of the element before flexbox layout is applied. Used internally for layout calculations.
+     */
+    preFlexheight?: number;
+    /**
+     * The text content of a text node.
+     */
+    text?: string;
+    /**
+     * Aligns flex items along the cross axis of the current line of the flex container.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex-properties
+     */
+    alignItems?: 'flexStart' | 'flexEnd' | 'center';
+    /**
+     * Aligns a flex item along the cross axis, overriding the `alignItems` value of the flex container.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex-properties
+     */
+    alignSelf?: 'flexStart' | 'flexEnd' | 'center';
+    /**
+     * The border style for all sides of the element. Takes an object with width and color properties.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects?id=border-and-borderradius
+     */
+    border?: BorderStyle;
+    /**
+     * The border style for the bottom side of the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects?id=border-and-borderradius
+     */
+    borderBottom?: SingleBorderStyle;
+    /**
+     * The border style for the left side of the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects?id=border-and-borderradius
+     */
+    borderLeft?: SingleBorderStyle;
+    /**
+     * The radius of the element's corners.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects?id=border-and-borderradius
+     */
+    borderRadius?: BorderRadius;
+    /**
+     * The border style for the right side of the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects?id=border-and-borderradius
+     */
+    borderRight?: SingleBorderStyle;
+    /**
+     * The border style for the top side of the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects?id=border-and-borderradius
+     */
+    borderTop?: SingleBorderStyle;
+    /**
+     * A shorthand to set both `centerX` and `centerY` to true.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=layout-and-positioning-elements
+     */
+    center?: boolean;
+    /**
+     * If `true`, centers the element horizontally within its parent.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=layout-and-positioning-elements
+     */
+    centerX?: boolean;
+    /**
+     * If `true`, centers the element vertically within its parent.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=layout-and-positioning-elements
+     */
+    centerY?: boolean;
+    /**
+     * Specifies the direction of the flex items.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    direction?: 'ltr' | 'rtl';
+    /**
+     * Defines how the flex container's size is determined. 'contain' allows it to grow with its content, 'fixed' keeps it at its specified size.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    flexBoundary?: 'contain' | 'fixed';
+    /**
+     * Defines how the flex container's cross-axis size is determined. 'fixed' keeps it at its specified size. Default is 'contain'.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    flexCrossBoundary?: 'fixed';
+    /**
+     * Specifies the direction of the main axis for flex items.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    /**
+     * The gap between flex items.
+     *
+     * @see @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    gap?: number;
+    /**
+     * The gap between flex rows.
+     *
+     * @see @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    rowGap?: number;
+    /**
+     * The gap between flex columns.
+     *
+     * @see @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    columnGap?: number;
+    /**
+     * Defines the alignment of flex items along the main axis.
+     *
+     * @see @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    justifyContent?: 'flexStart' | 'flexEnd' | 'center' | 'spaceBetween' | 'spaceAround' | 'spaceEvenly';
+    /**
+     * Applies a linear gradient effect to the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects
+     */
+    linearGradient?: LinearGradientProps;
+    /**
+     * Applies a radial gradient effect to the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/effects
+     */
+    radialGradient?: RadialGradientProps;
+    /**
+     * The margin on the bottom side of the element for a flexItem.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    marginBottom?: number;
+    /**
+     * The margin on the left side of the element for a flexItem.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    marginLeft?: number;
+    /**
+     * The margin on the right side of the element for a flexItem.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    marginRight?: number;
+    /**
+     * The margin on the top side of the element for a flexItem.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    marginTop?: number;
+    /**
+     * The padding on all sides of the flex element, or an array defining [Top, Right, Bottom, Left] padding.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    padding?: number | [number, number] | [number, number, number] | [number, number, number, number];
+    /**
+     * The margin on all sides of the flex element, or an array defining [Top, Right, Bottom, Left] margins.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    margin?: number | [number, number] | [number, number, number] | [number, number, number, number];
+    /**
+     * The x-coordinate of the element's position.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    x: number;
+    /**
+     * The y-coordinate of the element's position.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    y: number;
+    /**
+     * Throttles key press events by the specified number of milliseconds.
+     *
+     * @see https://lightning-tv.github.io/solid/#/primitives/useFocusManager?id=input-throttling-available-core-212
+     */
+    throttleInput?: number;
+    /**
+     * The width of the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    w: number;
+    /**
+     * The height of the element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    h: number;
+    /**
+     * The maximum width of the element.
+     */
+    maxWidth?: number;
+    /**
+     * The maximum height of the element.
+     */
+    maxHeight?: number;
+    /**
+     * The minimum width of the element.
+     */
+    minWidth?: number;
+    /**
+     * The minimum height of the element.
+     */
+    minHeight?: number;
+    /**
+     * The z-index of the element, which affects its stacking order.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    zIndex?: number;
+    /**
+     * Defines transitions for animatable properties.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/transitions?id=transitions-animations
+     */
+    transition?: Record<string, AnimationSettings | undefined | true | false> | true | false;
+    /**
+     * Optional handlers for animation events.
+     *
+     * Available animation events:
+     * - 'animating': Fired when the animation starts.
+     * - 'stopped': Fired (via setTimeout for the animation duration) when the animation completes.
+     *
+     * Each event handler is optional and maps to a corresponding event.
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/transitions?id=animation-callbacks
+     */
+    onAnimation?: Partial<Record<AnimationEvents, AnimationEventHandler>>;
+    /** Optional handler for when the element is created and rendered.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/ondestroy
+     */
+    onCreate?: (this: ElementNode, el: ElementNode) => void;
+    /**
+     * Optional handler for when the element is destroyed.
+     * It can return a promise to wait for the cleanup to finish before the element is destroyed.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/ondestroy
+     */
+    onDestroy?: (this: ElementNode, el: ElementNode) => Promise<void> | void;
+    /**
+     * Optional handlers for when the element is rendered—after creation and when switching parents.
+     *
+     * @see https://lightning-tv.github.io/solid/#/primitives/KeepAlive
+     */
+    onRender?: (this: ElementNode, el: ElementNode) => void;
+    /**
+     * Optional handlers for when the element is removed from a parent element.
+     *
+     * @see https://lightning-tv.github.io/solid/#/primitives/KeepAlive
+     */
+    onRemove?: (this: ElementNode, el: ElementNode) => void;
+    /**
+     * Listen to Events coming from the renderer
+     * @param NodeEvents
+     *
+     * Available events:
+     * - 'loaded'
+     * - 'failed'
+     * - 'freed'
+     * - 'inBounds'
+     * - 'outOfBounds'
+     * - 'inViewport'
+     * - 'outOfViewport'
+     *
+     * @typedef {'loaded' | 'failed' | 'freed' | 'inBounds' | 'outOfBounds' | 'inViewport' | 'outOfViewport'} NodeEvents
+     *
+     * @param {Partial<Record<NodeEvents, EventHandler>>} events - An object where the keys are event names from NodeEvents and the values are the respective event handlers.
+     * @returns {void}
+     *
+     * @see https://lightning-tv.github.io/solid/#/essentials/events
+     */
+    onEvent?: OnEvent;
+    /**
+     * The individual padding on each side of an element, acting as an override to the `padding` array property.
+     * `paddingTop`, `paddingRight`, `paddingBottom`, `paddingLeft`.
+     * Only in the new flex engine.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    /**
+     * Defines the order in which state styles are applied for this element.
+     * Overrides the global `Config.stateOrder`.
+     */
+    stateOrder?: DollarString[];
+}
+export declare class ElementNode {
+    constructor(name: string);
+    get effects(): StyleEffects | undefined;
+    /**
+     * Commit a built shader-props target back to `this.lng.shader`. When the
+     * node is already rendered we either convert the props into a real shader
+     * (first time) or self-assign so the DOM renderer's setter reapplies style;
+     * pre-render we just attach the bag for the upcoming `render()`.
+     */
+    _writeShaderTarget(target: unknown): void;
+    set effects(v: StyleEffects);
+    set id(id: string);
+    get id(): string | undefined;
+    get parent(): ElementNode | undefined;
+    set parent(p: ElementNode | undefined);
+    get height(): number;
+    set height(h: number);
+    get width(): number;
+    set width(w: number);
+    set fontWeight(v: unknown);
+    get fontWeight(): unknown;
+    set fontFamily(v: string | undefined);
+    get fontFamily(): string | undefined;
+    insertChild(node: ElementNode | ElementText | TextNode, beforeNode?: ElementNode | ElementText | TextNode | null): void;
+    removeChild(node: ElementNode | ElementText | TextNode): void;
+    get selectedNode(): ElementNode | undefined;
+    set shader(shaderProps: IRendererShader | [kind: string, props: IRendererShaderProps]);
+    _sendToLightningAnimatable(name: string, value: number): IAnimationController | undefined;
+    _fireAnimationEvents(name: string, value: number, animationSettings?: AnimationSettings): void;
+    _clearStateStyleFallbacksAfterTransitions(styleKeys: string[]): void;
+    animate(props: Partial<INodeAnimateProps<CoreShaderNode>>, animationSettings?: AnimationSettings): IAnimationController;
+    chain(props: Partial<INodeAnimateProps<CoreShaderNode>>, animationSettings?: AnimationSettings): this;
+    start(): Promise<void>;
+    emit(event: string, ...args: any[]): boolean;
+    setFocus(): void;
+    _layoutOnLoad(): void;
+    getText(this: ElementText): string;
+    rerender(): void;
+    destroy(): void;
+    _destroy(): void;
+    set style(style: Styles | undefined);
+    get style(): Styles;
+    set theme(styles: Styles | undefined);
+    get theme(): Styles;
+    get hasChildren(): boolean;
+    set src(src: string | null | undefined);
+    get src(): string | null | undefined;
+    getChildById(id: string): ElementText | ElementNode | undefined;
+    searchChildrenById(id: string): ElementNode | undefined;
+    set states(states: NodeStates);
+    get states(): States;
+    get animationSettings(): AnimationSettings | undefined;
+    set animationSettings(animationSettings: AnimationSettings | undefined);
+    set hidden(val: boolean);
+    get hidden(): boolean;
+    get preserve(): boolean;
+    set preserve(v: boolean);
+    /**
+     * Sets the autofocus state of the element.
+     * When set to a truthy value, the element will automatically gain focus.
+     * You can also set it to a signal to recalculate
+     *
+     * @param val - A value to determine if the element should autofocus.
+     *              A truthy value enables autofocus, otherwise disables it.
+     */
+    set autofocus(val: any);
+    get autofocus(): any;
+    /**
+     * Specifies the display behavior of an element. 'flex' enables flexbox layout.
+     *
+     * @default 'block'
+     * @see https://lightning-tv.github.io/solid/#/flow/layout?id=flex
+     */
+    get display(): 'flex' | 'block' | undefined;
+    set display(v: 'flex' | 'block' | undefined);
+    /**
+     * Callback run after flex layout is calculated on flex elements.
+     *
+     * @see https://lightning-tv.github.io/solid/#/flow/layout
+     */
+    get onLayout(): ((this: ElementNode, target: ElementNode) => void) | undefined;
+    set onLayout(fn: ((this: ElementNode, target: ElementNode) => void) | undefined);
+    requiresLayout(): boolean;
+    set updateLayoutOn(_v: unknown);
+    get updateLayoutOn(): unknown;
+    updateLayout(): void;
+    _stateChanged(): void;
+    render(topNode?: boolean): void;
+}
+export declare function createRawShaderAccessor<T>(key: keyof StyleEffects): {
+    set(this: ElementNode, value: T): void;
+    get(this: ElementNode): any;
+};
+export declare function shaderAccessor<T extends Record<string, any> | number>(key: 'border' | 'shadow' | 'rounded' | 'borderBottom' | 'borderLeft' | 'borderRight' | 'borderTop'): {
+    set(this: ElementNode, value: T): void;
+    get(this: ElementNode): any;
+};

package/dist/__package_types_tmp__/core/env.d.ts

@@ -0,0 +1,3 @@
+export declare const isDev: boolean;
+/** Whether element shaders are enabled */
+export declare const SHADERS_ENABLED: boolean;

package/dist/__package_types_tmp__/core/flex.d.ts

@@ -0,0 +1,2 @@
+import { type ElementNode } from './elementNode.js';
+export default function (node: ElementNode): boolean;

package/dist/__package_types_tmp__/core/flexLayout.d.ts

@@ -0,0 +1,2 @@
+import { type ElementNode } from './elementNode.js';
+export default function (node: ElementNode): boolean;

package/dist/__package_types_tmp__/core/focusKeyTypes.d.ts

@@ -0,0 +1,47 @@
+import { ElementNode } from './elementNode.js';
+export interface FocusNode {
+    onFocus?: (this: ElementNode, currentFocusedElm: ElementNode, prevFocusedElm: ElementNode | undefined, nodeWithCallback: ElementNode) => void;
+    onFocusChanged?: (this: ElementNode, hasFocus: boolean, currentFocusedElm: ElementNode, prevFocusedElm: ElementNode | undefined, nodeWithCallback: ElementNode) => void;
+    onBlur?: (this: ElementNode, currentFocusedElm: ElementNode, prevFocusedElm: ElementNode, nodeWithCallback: ElementNode) => void;
+    onKeyPress?: (this: ElementNode, e: KeyboardEvent, mappedKeyEvent: string | undefined, handlerElm: ElementNode, currentFocusedElm: ElementNode) => KeyHandlerReturn;
+    onKeyHold?: (this: ElementNode, e: KeyboardEvent, mappedKeyEvent: string | undefined, handlerElm: ElementNode, currentFocusedElm: ElementNode) => KeyHandlerReturn;
+}
+export type KeyNameOrKeyCode = string | number;
+export interface DefaultKeyMap {
+    Left: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    Right: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    Up: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    Down: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    Enter: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    Last: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+}
+export interface KeyMap extends DefaultKeyMap {
+    [key: string]: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+}
+export interface DefaultKeyHoldMap {
+    EnterHold: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    LeftHold: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    RightHold: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    UpHold: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+    DownHold: KeyNameOrKeyCode | KeyNameOrKeyCode[] | null;
+}
+export type EventHandlers<Map> = {
+    [K in keyof Map as `on${Capitalize<string & K>}`]?: KeyHandler;
+} & {
+    [K in keyof Map as `on${Capitalize<string & K>}Release`]?: KeyHandler;
+} & {
+    [K in keyof Map as `onCapture${Capitalize<string & K>}`]?: KeyHandler;
+} & {
+    onCaptureKey?: KeyHandler;
+    onCaptureKeyRelease?: KeyHandler;
+};
+export interface KeyHoldMap extends DefaultKeyHoldMap {
+}
+export type KeyHandlerReturn = boolean | void;
+export type KeyHandler = (this: ElementNode, e: KeyboardEvent, target: ElementNode, handlerElm: ElementNode, mappedEvent?: string) => KeyHandlerReturn;
+export type ForwardFocusHandler = (this: ElementNode, elm: ElementNode) => boolean | void;
+export type KeyHoldOptions = {
+    userKeyHoldMap: Partial<KeyHoldMap>;
+    holdThreshold?: number;
+    repeatInterval?: number;
+};

package/dist/__package_types_tmp__/core/focusManager.d.ts

@@ -0,0 +1,34 @@
+export type * from './focusKeyTypes.js';
+import { ElementNode } from './elementNode.js';
+import type { KeyHoldOptions, KeyMap } from './focusKeyTypes.js';
+export interface FocusHistoryEntry {
+    timestamp: number;
+    keyPressed: string | number | undefined;
+    mappedKey: string | undefined;
+    prev: ElementNode | undefined;
+    next: ElementNode;
+}
+/** Returns a snapshot of the focus history ring buffer (up to 50 entries). */
+export declare const getFocusHistory: () => Readonly<FocusHistoryEntry[]>;
+/**
+ * Prints the last `count` focus history entries as a console.table.
+ * Callable at any time from the browser console:  `printFocusHistory(20)`
+ */
+export declare const printFocusHistory: (count: number) => void;
+/**
+ * Built-in "apply focus" routine: diffs the focus path, fires
+ * `onFocus`/`onBlur`/`onFocusChanged`, records history, then publishes the
+ * active element through the `Config.setActiveElement` hook.
+ *
+ * This is what `ElementNode.setFocus()` ultimately invokes. It is intentionally
+ * *not* the public `setActiveElement` export — that name is the raw signal
+ * setter (see {@link ./activeElement.ts}). Keeping them separate is what stops
+ * a custom `Config.setActiveElement` (wired to a setter) from recursing back
+ * through the focus-path logic.
+ */
+export declare const setActiveElementCore: (elm: ElementNode) => void;
+export declare const focusPathStore: import("svelte/store").Writable<ElementNode[]>;
+export declare const focusPath: (() => ElementNode[]) & import("svelte/store").Writable<ElementNode[]>;
+export declare const setFocusPath: (path: ElementNode[]) => void;
+export declare const createFocusManager: (userKeyMap?: Partial<KeyMap>, keyHoldOptions?: KeyHoldOptions) => (() => void);
+export declare const useFocusManager: (userKeyMap?: Partial<KeyMap>, keyHoldOptions?: KeyHoldOptions) => (() => void);

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

@@ -0,0 +1,14 @@
+export * from './activeElement.js';
+export * from './config.js';
+export * from './elementNode.js';
+export * from './focusKeyTypes.js';
+export * from './focusManager.js';
+export * from './lightningInit.js';
+export * from './nodeTypes.js';
+export * from './root.js';
+export * from './shaders.js';
+export * from './svelteNode.js';
+export * from './utils.js';
+export type * from './intrinsicTypes.js';
+export type { INode } from '@lightningjs/renderer';
+export { assertTruthy, deg2Rad } from '@lightningjs/renderer/utils';