@gtkx/react 0.6.1 → 0.8.0

package/dist/nodes/stack-page-props.js

@@ -0,0 +1,23 @@
+export function applyStackPageProps(page, props) {
+    if (props.name !== undefined) {
+        page.setName(props.name);
+    }
+    if (props.title !== undefined) {
+        page.setTitle(props.title);
+    }
+    if (props.iconName !== undefined) {
+        page.setIconName(props.iconName);
+    }
+    if (props.needsAttention !== undefined) {
+        page.setNeedsAttention(props.needsAttention);
+    }
+    if (props.visible !== undefined) {
+        page.setVisible(props.visible);
+    }
+    if (props.useUnderline !== undefined) {
+        page.setUseUnderline(props.useUnderline);
+    }
+    if (props.badgeNumber !== undefined && page.setBadgeNumber) {
+        page.setBadgeNumber(props.badgeNumber);
+    }
+}

package/dist/nodes/stack.d.ts

@@ -1,36 +1,22 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-import { type ChildContainer, type StackPageContainer, type StackPageProps } from "../container-interfaces.js";
+import { type StackPageContainer, type StackPageProps } from "../container-interfaces.js";
 import type { Props } from "../factory.js";
-import { Node } from "../node.js";
-export declare class StackNode extends Node<Gtk.Stack> implements StackPageContainer, ChildContainer {
+import type { Node } from "../node.js";
+import { PagedStackNode } from "./paged-stack.js";
+import { VirtualSlotNode } from "./virtual-slot.js";
+export declare class StackNode extends PagedStackNode<Gtk.Stack> {
     static matches(type: string): boolean;
-    private pendingVisibleChildName;
     addStackPage(child: Gtk.Widget, props: StackPageProps): void;
-    private applyPendingVisibleChild;
-    insertStackPageBefore(child: Gtk.Widget, props: StackPageProps, _beforeChild: Gtk.Widget): void;
-    removeStackPage(child: Gtk.Widget): void;
-    updateStackPageProps(child: Gtk.Widget, props: StackPageProps): void;
-    private applyStackPageProps;
-    attachChild(child: Gtk.Widget): void;
-    insertChildBefore(child: Gtk.Widget, _before: Gtk.Widget): void;
-    detachChild(child: Gtk.Widget): void;
-    protected consumedProps(): Set<string>;
-    private setVisibleChildOrDefer;
-    updateProps(oldProps: Props, newProps: Props): void;
+    protected addChildToWidget(child: Gtk.Widget): void;
 }
-export declare class StackPageNode extends Node {
+export declare class StackPageNode extends VirtualSlotNode<StackPageContainer, StackPageProps> {
+    static consumedPropNames: string[];
     static matches(type: string): boolean;
-    protected isVirtual(): boolean;
-    private pageProps;
-    private childWidget;
-    private parentContainer;
-    initialize(props: Props): void;
-    private extractPageProps;
-    getChildWidget(): Gtk.Widget | null;
-    appendChild(child: Node): void;
-    attachToParent(parent: Node): void;
-    attachToParentBefore(parent: Node, before: Node): void;
-    detachFromParent(parent: Node): void;
-    protected consumedProps(): Set<string>;
+    protected isValidContainer(parent: Node): parent is Node & StackPageContainer;
+    protected extractSlotProps(props: Props): StackPageProps;
+    protected addToContainer(container: StackPageContainer, child: Gtk.Widget, props: StackPageProps): void;
+    protected insertBeforeInContainer(container: StackPageContainer, child: Gtk.Widget, props: StackPageProps, before: Gtk.Widget): void;
+    protected removeFromContainer(container: StackPageContainer, child: Gtk.Widget): void;
+    protected updateInContainer(container: StackPageContainer, child: Gtk.Widget, props: StackPageProps): void;
     updateProps(oldProps: Props, newProps: Props): void;
 }

package/dist/nodes/stack.js

@@ -1,10 +1,12 @@
-import { isStackPageContainer, } from "../container-interfaces.js";
-import { Node } from "../node.js";
-export class StackNode extends Node {
+import { isStackPageContainer } from "../container-interfaces.js";
+import { PagedStackNode } from "./paged-stack.js";
+import { applyStackPageProps } from "./stack-page-props.js";
+import { VirtualSlotNode } from "./virtual-slot.js";
+const STACK_PAGE_PROP_KEYS = ["name", "title", "iconName", "needsAttention", "visible", "useUnderline", "badgeNumber"];
+export class StackNode extends PagedStackNode {
     static matches(type) {
         return type === "Stack" || type === "Stack.Root";
     }
-    pendingVisibleChildName = null;
     addStackPage(child, props) {
         const { name, title } = props;
         let stackPage;
@@ -17,160 +19,46 @@ export class StackNode extends Node {
         else {
             stackPage = this.widget.addChild(child);
         }
-        this.applyStackPageProps(stackPage, props);
+        applyStackPageProps(stackPage, props);
         this.applyPendingVisibleChild();
     }
-    applyPendingVisibleChild() {
-        if (this.pendingVisibleChildName !== null) {
-            const child = this.widget.getChildByName(this.pendingVisibleChildName);
-            if (child) {
-                this.widget.setVisibleChild(child);
-                this.pendingVisibleChildName = null;
-            }
-        }
-    }
-    insertStackPageBefore(child, props, _beforeChild) {
-        this.addStackPage(child, props);
-    }
-    removeStackPage(child) {
-        this.widget.remove(child);
-    }
-    updateStackPageProps(child, props) {
-        const stackPage = this.widget.getPage(child);
-        this.applyStackPageProps(stackPage, props);
-    }
-    applyStackPageProps(stackPage, props) {
-        if (props.name !== undefined) {
-            stackPage.setName(props.name);
-        }
-        if (props.title !== undefined) {
-            stackPage.setTitle(props.title);
-        }
-        if (props.iconName !== undefined) {
-            stackPage.setIconName(props.iconName);
-        }
-        if (props.needsAttention !== undefined) {
-            stackPage.setNeedsAttention(props.needsAttention);
-        }
-        if (props.visible !== undefined) {
-            stackPage.setVisible(props.visible);
-        }
-        if (props.useUnderline !== undefined) {
-            stackPage.setUseUnderline(props.useUnderline);
-        }
-    }
-    attachChild(child) {
+    addChildToWidget(child) {
         this.widget.addChild(child);
     }
-    insertChildBefore(child, _before) {
-        this.widget.addChild(child);
-    }
-    detachChild(child) {
-        this.widget.remove(child);
-    }
-    consumedProps() {
-        const consumed = super.consumedProps();
-        consumed.add("visibleChildName");
-        return consumed;
-    }
-    setVisibleChildOrDefer(name) {
-        const child = this.widget.getChildByName(name);
-        if (child) {
-            this.widget.setVisibleChild(child);
-            this.pendingVisibleChildName = null;
-        }
-        else {
-            this.pendingVisibleChildName = name;
-        }
-    }
-    updateProps(oldProps, newProps) {
-        if (newProps.visibleChildName !== undefined) {
-            this.setVisibleChildOrDefer(newProps.visibleChildName);
-        }
-        super.updateProps(oldProps, newProps);
-    }
 }
-export class StackPageNode extends Node {
+export class StackPageNode extends VirtualSlotNode {
+    static consumedPropNames = STACK_PAGE_PROP_KEYS;
     static matches(type) {
-        return type === "Stack.Page";
+        return type === "Stack.Page" || type === "AdwViewStack.Page";
     }
-    isVirtual() {
-        return true;
+    isValidContainer(parent) {
+        return isStackPageContainer(parent);
     }
-    pageProps = {};
-    childWidget = null;
-    parentContainer = null;
-    initialize(props) {
-        this.pageProps = this.extractPageProps(props);
-        super.initialize(props);
-    }
-    extractPageProps(props) {
+    extractSlotProps(props) {
         return {
-            name: typeof props.name === "string" ? props.name : undefined,
-            title: typeof props.title === "string" ? props.title : undefined,
-            iconName: typeof props.iconName === "string" ? props.iconName : undefined,
-            needsAttention: typeof props.needsAttention === "boolean" ? props.needsAttention : undefined,
-            visible: typeof props.visible === "boolean" ? props.visible : undefined,
-            useUnderline: typeof props.useUnderline === "boolean" ? props.useUnderline : undefined,
+            name: props.name,
+            title: props.title,
+            iconName: props.iconName,
+            needsAttention: props.needsAttention,
+            visible: props.visible,
+            useUnderline: props.useUnderline,
+            badgeNumber: props.badgeNumber,
         };
     }
-    getChildWidget() {
-        return this.childWidget;
-    }
-    appendChild(child) {
-        const childWidget = child.getWidget();
-        if (childWidget) {
-            this.childWidget = childWidget;
-        }
-    }
-    attachToParent(parent) {
-        if (isStackPageContainer(parent) && this.childWidget) {
-            this.parentContainer = parent;
-            parent.addStackPage(this.childWidget, this.pageProps);
-        }
+    addToContainer(container, child, props) {
+        container.addStackPage(child, props);
     }
-    attachToParentBefore(parent, before) {
-        if (isStackPageContainer(parent) && this.childWidget) {
-            this.parentContainer = parent;
-            const beforePage = before instanceof StackPageNode ? before.getChildWidget() : before.getWidget();
-            if (beforePage) {
-                parent.insertStackPageBefore(this.childWidget, this.pageProps, beforePage);
-            }
-            else {
-                parent.addStackPage(this.childWidget, this.pageProps);
-            }
-        }
+    insertBeforeInContainer(container, child, props, before) {
+        container.insertStackPageBefore(child, props, before);
     }
-    detachFromParent(parent) {
-        if (isStackPageContainer(parent) && this.childWidget) {
-            parent.removeStackPage(this.childWidget);
-            this.parentContainer = null;
-        }
+    removeFromContainer(container, child) {
+        container.removeStackPage(child);
     }
-    consumedProps() {
-        const consumed = super.consumedProps();
-        consumed.add("name");
-        consumed.add("title");
-        consumed.add("iconName");
-        consumed.add("needsAttention");
-        consumed.add("visible");
-        consumed.add("useUnderline");
-        return consumed;
+    updateInContainer(container, child, props) {
+        container.updateStackPageProps(child, props);
     }
     updateProps(oldProps, newProps) {
-        const newPageProps = this.extractPageProps(newProps);
-        const propsChanged = oldProps.name !== newProps.name ||
-            oldProps.title !== newProps.title ||
-            oldProps.iconName !== newProps.iconName ||
-            oldProps.needsAttention !== newProps.needsAttention ||
-            oldProps.visible !== newProps.visible ||
-            oldProps.useUnderline !== newProps.useUnderline;
-        if (propsChanged) {
-            this.pageProps = newPageProps;
-            if (this.parentContainer && this.childWidget) {
-                this.parentContainer.updateStackPageProps(this.childWidget, this.pageProps);
-            }
-        }
+        this.updateSlotPropsIfChanged(oldProps, newProps, STACK_PAGE_PROP_KEYS);
         super.updateProps(oldProps, newProps);
     }
 }

package/dist/nodes/string-list-container.d.ts

@@ -0,0 +1,41 @@
+import * as Gio from "@gtkx/ffi/gio";
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { Props } from "../factory.js";
+import type { Node } from "../node.js";
+import { Node as NodeClass } from "../node.js";
+import { StringListStore } from "./string-list-store.js";
+export type StringListItem = {
+    id: string;
+    label: string;
+};
+type StringListContainer = {
+    addStringListItem(id: string, label: string): void;
+    insertStringListItemBefore(id: string, label: string, beforeId: string): void;
+    removeStringListItem(id: string): void;
+    updateStringListItem(oldId: string, newId: string, newLabel: string): void;
+};
+export declare const isStringListContainer: (node: Node) => node is Node & StringListContainer;
+type StringListContainerState = {
+    store: StringListStore;
+    onSelectionChanged?: (id: string) => void;
+    initialSelection?: string;
+    hasAppliedInitialSelection: boolean;
+};
+type StringListWidget = Gtk.Widget & {
+    setModel(model: Gio.ListModel | null): void;
+    getSelected(): number;
+    setSelected(position: number): void;
+};
+export declare abstract class StringListContainerNode<T extends StringListWidget> extends NodeClass<T, StringListContainerState> implements StringListContainer {
+    static consumedPropNames: string[];
+    initialize(props: Props): void;
+    private connectSelectionHandler;
+    addStringListItem(id: string, label: string): void;
+    private scheduleInitialSelectionIfNeeded;
+    private applyInitialSelection;
+    insertStringListItemBefore(id: string, label: string, beforeId: string): void;
+    removeStringListItem(id: string): void;
+    updateStringListItem(oldId: string, newId: string, newLabel: string): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+}
+export {};

package/dist/nodes/string-list-container.js

@@ -0,0 +1,90 @@
+import { getInterface } from "@gtkx/ffi";
+import * as Gio from "@gtkx/ffi/gio";
+import { Node as NodeClass } from "../node.js";
+import { getCallbackChange } from "../props.js";
+import { StringListStore } from "./string-list-store.js";
+export const isStringListContainer = (node) => "addStringListItem" in node &&
+    "insertStringListItemBefore" in node &&
+    "removeStringListItem" in node &&
+    "updateStringListItem" in node;
+const SELECTION_SIGNAL = "notify::selected";
+export class StringListContainerNode extends NodeClass {
+    static consumedPropNames = ["onSelectionChanged", "selectedId"];
+    initialize(props) {
+        const store = new StringListStore();
+        const onSelectionChanged = props.onSelectionChanged;
+        const initialSelection = props.selectedId;
+        this.state = { store, onSelectionChanged, initialSelection, hasAppliedInitialSelection: false };
+        super.initialize(props);
+        this.widget.setModel(getInterface(store.getModel().id, Gio.ListModel));
+    }
+    connectSelectionHandler() {
+        const handler = () => {
+            const index = this.widget.getSelected();
+            const id = this.state.store.getIdAtIndex(index);
+            if (id !== undefined) {
+                this.state.onSelectionChanged?.(id);
+            }
+        };
+        this.connectSignal(this.widget, SELECTION_SIGNAL, handler);
+    }
+    addStringListItem(id, label) {
+        this.state.store.append(id, label);
+        this.scheduleInitialSelectionIfNeeded();
+    }
+    scheduleInitialSelectionIfNeeded() {
+        if (!this.state.hasAppliedInitialSelection) {
+            this.state.hasAppliedInitialSelection = true;
+            queueMicrotask(() => this.applyInitialSelection());
+        }
+    }
+    applyInitialSelection() {
+        if (this.state.initialSelection !== undefined) {
+            const index = this.state.store.getIndexForId(this.state.initialSelection);
+            if (index !== -1) {
+                this.widget.setSelected(index);
+            }
+        }
+        if (this.state.onSelectionChanged) {
+            this.connectSelectionHandler();
+            const currentIndex = this.widget.getSelected();
+            const id = this.state.store.getIdAtIndex(currentIndex);
+            if (id !== undefined) {
+                this.state.onSelectionChanged(id);
+            }
+        }
+    }
+    insertStringListItemBefore(id, label, beforeId) {
+        this.state.store.insertBefore(id, label, beforeId);
+    }
+    removeStringListItem(id) {
+        this.state.store.remove(id);
+    }
+    updateStringListItem(oldId, newId, newLabel) {
+        this.state.store.update(oldId, newId, newLabel);
+    }
+    updateProps(oldProps, newProps) {
+        const oldCallback = oldProps.onSelectionChanged;
+        const newCallback = newProps.onSelectionChanged;
+        const change = getCallbackChange(oldCallback, newCallback);
+        if (change.action !== "none") {
+            this.state.onSelectionChanged = change.callback;
+            if (change.action === "disconnect") {
+                this.disconnectSignal(SELECTION_SIGNAL);
+            }
+            else if (change.action === "connect") {
+                this.connectSelectionHandler();
+            }
+        }
+        const oldSelected = oldProps.selectedId;
+        const newSelected = newProps.selectedId;
+        if (oldSelected !== newSelected && newSelected !== undefined) {
+            this.state.initialSelection = newSelected;
+            const index = this.state.store.getIndexForId(newSelected);
+            if (index !== -1) {
+                this.widget.setSelected(index);
+            }
+        }
+        super.updateProps(oldProps, newProps);
+    }
+}

package/dist/nodes/string-list-item.d.ts

@@ -0,0 +1,15 @@
+import type { Props } from "../factory.js";
+import { Node } from "../node.js";
+import { type StringListItem } from "./string-list-container.js";
+export declare abstract class StringListItemNode extends Node<never> {
+    static consumedPropNames: string[];
+    protected isVirtual(): boolean;
+    private id;
+    private label;
+    initialize(props: Props): void;
+    getStringListItem(): StringListItem;
+    attachToParent(parent: Node): void;
+    attachToParentBefore(parent: Node, before: Node): void;
+    detachFromParent(parent: Node): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+}

package/dist/nodes/string-list-item.js

@@ -0,0 +1,48 @@
+import { Node } from "../node.js";
+import { isStringListContainer } from "./string-list-container.js";
+export class StringListItemNode extends Node {
+    static consumedPropNames = ["id", "label"];
+    isVirtual() {
+        return true;
+    }
+    id = "";
+    label = "";
+    initialize(props) {
+        this.id = props.id;
+        this.label = props.label;
+        super.initialize(props);
+    }
+    getStringListItem() {
+        return { id: this.id, label: this.label };
+    }
+    attachToParent(parent) {
+        if (isStringListContainer(parent)) {
+            parent.addStringListItem(this.id, this.label);
+        }
+    }
+    attachToParentBefore(parent, before) {
+        if (isStringListContainer(parent) && before instanceof StringListItemNode) {
+            parent.insertStringListItemBefore(this.id, this.label, before.id);
+        }
+        else {
+            this.attachToParent(parent);
+        }
+    }
+    detachFromParent(parent) {
+        if (isStringListContainer(parent)) {
+            parent.removeStringListItem(this.id);
+        }
+    }
+    updateProps(oldProps, newProps) {
+        const oldId = oldProps.id;
+        const newId = newProps.id;
+        const oldLabel = oldProps.label;
+        const newLabel = newProps.label;
+        if ((oldId !== newId || oldLabel !== newLabel) && this.parent && isStringListContainer(this.parent)) {
+            this.parent.updateStringListItem(this.id, newId, newLabel);
+            this.id = newId;
+            this.label = newLabel;
+        }
+        super.updateProps(oldProps, newProps);
+    }
+}

package/dist/nodes/string-list-store.d.ts

@@ -0,0 +1,13 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+export declare class StringListStore {
+    private stringList;
+    private ids;
+    constructor();
+    getModel(): Gtk.StringList;
+    append(id: string, label: string): void;
+    insertBefore(id: string, label: string, beforeId: string): void;
+    remove(id: string): void;
+    update(oldId: string, newId: string, newLabel: string): void;
+    getIdAtIndex(index: number): string | undefined;
+    getIndexForId(id: string): number;
+}

package/dist/nodes/string-list-store.js

@@ -0,0 +1,44 @@
+import * as Gtk from "@gtkx/ffi/gtk";
+export class StringListStore {
+    stringList;
+    ids = [];
+    constructor() {
+        this.stringList = new Gtk.StringList([]);
+    }
+    getModel() {
+        return this.stringList;
+    }
+    append(id, label) {
+        this.stringList.append(label);
+        this.ids.push(id);
+    }
+    insertBefore(id, label, beforeId) {
+        const beforeIndex = this.ids.indexOf(beforeId);
+        if (beforeIndex === -1) {
+            this.append(id, label);
+            return;
+        }
+        this.stringList.splice(beforeIndex, 0, [label]);
+        this.ids.splice(beforeIndex, 0, id);
+    }
+    remove(id) {
+        const index = this.ids.indexOf(id);
+        if (index !== -1) {
+            this.stringList.remove(index);
+            this.ids.splice(index, 1);
+        }
+    }
+    update(oldId, newId, newLabel) {
+        const index = this.ids.indexOf(oldId);
+        if (index !== -1) {
+            this.stringList.splice(index, 1, [newLabel]);
+            this.ids[index] = newId;
+        }
+    }
+    getIdAtIndex(index) {
+        return this.ids[index];
+    }
+    getIndexForId(id) {
+        return this.ids.indexOf(id);
+    }
+}

package/dist/nodes/text-view.d.ts

@@ -2,7 +2,7 @@ import type * as Gtk from "@gtkx/ffi/gtk";
 import type { Props } from "../factory.js";
 import { Node } from "../node.js";
 export declare class TextViewNode extends Node<Gtk.TextView> {
+    static consumedPropNames: string[];
     static matches(type: string): boolean;
-    protected consumedProps(): Set<string>;
     updateProps(oldProps: Props, newProps: Props): void;
 }

package/dist/nodes/text-view.js

@@ -1,13 +1,9 @@
 import { Node } from "../node.js";
 export class TextViewNode extends Node {
+    static consumedPropNames = ["buffer"];
     static matches(type) {
         return type === "TextView";
     }
-    consumedProps() {
-        const consumed = super.consumedProps();
-        consumed.add("buffer");
-        return consumed;
-    }
     updateProps(oldProps, newProps) {
         if (oldProps.buffer !== newProps.buffer) {
             const buffer = newProps.buffer;

package/dist/nodes/toggle-button.d.ts

@@ -13,12 +13,12 @@ type ToggleButtonState = {
  * suppressing callbacks when the signal was caused by a programmatic update.
  */
 export declare class ToggleButtonNode extends Node<Gtk.ToggleButton, ToggleButtonState> {
+    static consumedPropNames: string[];
     static matches(type: string): boolean;
     initialize(props: Props): void;
     attachToParent(parent: Node): void;
     attachToParentBefore(parent: Node, before: Node): void;
     detachFromParent(parent: Node): void;
-    protected consumedProps(): Set<string>;
     updateProps(_oldProps: Props, newProps: Props): void;
     protected connectSignal(widget: Gtk.Widget, eventName: string, handler: (...args: unknown[]) => unknown): void;
 }

package/dist/nodes/toggle-button.js

@@ -9,6 +9,7 @@ import { Node } from "../node.js";
  * suppressing callbacks when the signal was caused by a programmatic update.
  */
 export class ToggleButtonNode extends Node {
+    static consumedPropNames = ["active"];
     static matches(type) {
         return type === "ToggleButton.Root";
     }
@@ -43,9 +44,6 @@ export class ToggleButtonNode extends Node {
         }
         super.detachFromParent(parent);
     }
-    consumedProps() {
-        return new Set(["children", "active"]);
-    }
     updateProps(_oldProps, newProps) {
         const widget = this.getWidget();
         if (!widget) {

package/dist/nodes/view-stack.d.ts

@@ -0,0 +1,9 @@
+import type * as Adw from "@gtkx/ffi/adw";
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { StackPageProps } from "../container-interfaces.js";
+import { PagedStackNode } from "./paged-stack.js";
+export declare class ViewStackNode extends PagedStackNode<Adw.ViewStack> {
+    static matches(type: string): boolean;
+    addStackPage(child: Gtk.Widget, props: StackPageProps): void;
+    protected addChildToWidget(child: Gtk.Widget): void;
+}

package/dist/nodes/view-stack.js

@@ -0,0 +1,28 @@
+import { PagedStackNode } from "./paged-stack.js";
+import { applyStackPageProps } from "./stack-page-props.js";
+export class ViewStackNode extends PagedStackNode {
+    static matches(type) {
+        return type === "AdwViewStack" || type === "AdwViewStack.Root";
+    }
+    addStackPage(child, props) {
+        const { name, title, iconName } = props;
+        let page;
+        if (title !== undefined && iconName !== undefined) {
+            page = this.widget.addTitledWithIcon(child, title, iconName, name ?? null);
+        }
+        else if (title !== undefined) {
+            page = this.widget.addTitled(child, title, name ?? null);
+        }
+        else if (name !== undefined) {
+            page = this.widget.addNamed(child, name);
+        }
+        else {
+            page = this.widget.add(child);
+        }
+        applyStackPageProps(page, props);
+        this.applyPendingVisibleChild();
+    }
+    addChildToWidget(child) {
+        this.widget.add(child);
+    }
+}

package/dist/nodes/virtual-item.d.ts

@@ -0,0 +1,20 @@
+import type { Props } from "../factory.js";
+import { Node } from "../node.js";
+/**
+ * Base class for virtual item nodes used in list-based containers.
+ * Virtual nodes don't create GTK widgets directly but represent items
+ * in list models (ListView, GridView, ColumnView).
+ */
+export declare abstract class VirtualItemNode extends Node<never> {
+    static consumedPropNames: string[];
+    protected isVirtual(): boolean;
+    private id;
+    private item;
+    initialize(props: Props): void;
+    getId(): string;
+    getItem(): unknown;
+    attachToParent(parent: Node): void;
+    attachToParentBefore(parent: Node, before: Node): void;
+    detachFromParent(parent: Node): void;
+    updateProps(oldProps: Props, newProps: Props): void;
+}