@gtkx/react 0.17.2 → 0.18.0

package/dist/nodes/internal/text-tag-styles.js

@@ -1,52 +0,0 @@
-import { hasChanged } from "./utils.js";
-const STYLE_PROPS = {
-    background: "setBackground",
-    backgroundFullHeight: "setBackgroundFullHeight",
-    foreground: "setForeground",
-    family: "setFamily",
-    font: "setFont",
-    sizePoints: "setSizePoints",
-    size: "setSize",
-    scale: "setScale",
-    weight: "setWeight",
-    style: "setStyle",
-    stretch: "setStretch",
-    variant: "setVariant",
-    strikethrough: "setStrikethrough",
-    underline: "setUnderline",
-    overline: "setOverline",
-    rise: "setRise",
-    letterSpacing: "setLetterSpacing",
-    lineHeight: "setLineHeight",
-    leftMargin: "setLeftMargin",
-    rightMargin: "setRightMargin",
-    indent: "setIndent",
-    pixelsAboveLines: "setPixelsAboveLines",
-    pixelsBelowLines: "setPixelsBelowLines",
-    pixelsInsideWrap: "setPixelsInsideWrap",
-    justification: "setJustification",
-    direction: "setDirection",
-    wrapMode: "setWrapMode",
-    editable: "setEditable",
-    invisible: "setInvisible",
-    allowBreaks: "setAllowBreaks",
-    insertHyphens: "setInsertHyphens",
-    fallback: "setFallback",
-    accumulativeMargin: "setAccumulativeMargin",
-    paragraphBackground: "setParagraphBackground",
-    showSpaces: "setShowSpaces",
-    textTransform: "setTextTransform",
-    fontFeatures: "setFontFeatures",
-    language: "setLanguage",
-};
-export function applyStyleChanges(tag, oldProps, newProps) {
-    for (const prop of Object.keys(STYLE_PROPS)) {
-        if (hasChanged(oldProps, newProps, prop)) {
-            const value = newProps[prop];
-            if (value !== undefined) {
-                const setter = tag[STYLE_PROPS[prop]];
-                setter.call(tag, value);
-            }
-        }
-    }
-}

package/dist/nodes/internal/tree-list-item-renderer.d.ts

@@ -1,26 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { ReactNode } from "react";
-import type Reconciler from "react-reconciler";
-import { BaseItemRenderer } from "./base-item-renderer.js";
-import type { TreeStore } from "./tree-store.js";
-export type TreeRenderItemFn<T> = (item: T | null, row: Gtk.TreeListRow | null) => ReactNode;
-export declare class TreeListItemRenderer extends BaseItemRenderer<TreeStore> {
-    private expanders;
-    private setupComplete;
-    private pendingBinds;
-    private renderFn;
-    private boundItems;
-    setRenderFn(renderFn: TreeRenderItemFn<unknown> | null): void;
-    rebindItem(id: string): void;
-    protected getStoreTypeName(): string;
-    dispose(): void;
-    protected renderItem(_ptr: number): ReactNode;
-    protected getItemFromListItem(listItem: Gtk.ListItem): unknown;
-    protected onSetup(listItem: Gtk.ListItem, ptr: number): Gtk.Widget;
-    protected onSetupComplete(ptr: number): void;
-    protected onBind(listItem: Gtk.ListItem, ptr: number, fiberRoot: Reconciler.FiberRoot): void;
-    protected onUnbind(listItem: Gtk.ListItem): void;
-    protected onTeardown(_listItem: Gtk.ListItem, ptr: number): void;
-    private processPendingBind;
-    private renderBind;
-}

package/dist/nodes/internal/tree-list-item-renderer.js

@@ -1,134 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import { reconciler } from "../../reconciler.js";
-import { BaseItemRenderer } from "./base-item-renderer.js";
-export class TreeListItemRenderer extends BaseItemRenderer {
-    expanders = new Map();
-    setupComplete = new Set();
-    pendingBinds = new Map();
-    renderFn = () => null;
-    boundItems = new Map();
-    setRenderFn(renderFn) {
-        this.renderFn = renderFn;
-    }
-    rebindItem(id) {
-        const binding = this.boundItems.get(id);
-        if (!binding)
-            return;
-        const fiberRoot = this.fiberRoots.get(binding.ptr);
-        if (!fiberRoot)
-            return;
-        const expander = this.expanders.get(binding.ptr);
-        if (!expander)
-            return;
-        this.renderBind(binding.ptr, expander, binding.treeListRow, id, fiberRoot);
-    }
-    getStoreTypeName() {
-        return "tree store";
-    }
-    dispose() {
-        super.dispose();
-        this.expanders.clear();
-        this.setupComplete.clear();
-        this.pendingBinds.clear();
-        this.boundItems.clear();
-    }
-    renderItem(_ptr) {
-        return this.renderFn?.(null, null);
-    }
-    getItemFromListItem(listItem) {
-        const treeListRow = listItem.getItem();
-        if (!(treeListRow instanceof Gtk.TreeListRow))
-            return null;
-        const stringObject = treeListRow.getItem();
-        if (!(stringObject instanceof Gtk.StringObject))
-            return null;
-        return this.getStore().getItem(stringObject.getString());
-    }
-    onSetup(listItem, ptr) {
-        const expander = new Gtk.TreeExpander();
-        const box = this.createBox();
-        expander.setChild(box);
-        listItem.setChild(expander);
-        this.expanders.set(ptr, expander);
-        return box;
-    }
-    onSetupComplete(ptr) {
-        this.setupComplete.add(ptr);
-        this.processPendingBind(ptr);
-    }
-    onBind(listItem, ptr, fiberRoot) {
-        const expander = this.expanders.get(ptr);
-        if (!expander)
-            return;
-        const treeListRow = listItem.getItem();
-        if (!(treeListRow instanceof Gtk.TreeListRow))
-            return;
-        expander.setListRow(treeListRow);
-        const stringObject = treeListRow.getItem();
-        if (!(stringObject instanceof Gtk.StringObject))
-            return;
-        const id = stringObject.getString();
-        this.boundItems.set(id, { ptr, treeListRow });
-        if (!this.setupComplete.has(ptr)) {
-            this.pendingBinds.set(ptr, { treeListRow, expander, id });
-            return;
-        }
-        this.renderBind(ptr, expander, treeListRow, id, fiberRoot);
-    }
-    onUnbind(listItem) {
-        const expander = listItem.getChild();
-        if (expander instanceof Gtk.TreeExpander) {
-            expander.setListRow(null);
-            const treeListRow = listItem.getItem();
-            if (treeListRow instanceof Gtk.TreeListRow) {
-                const stringObject = treeListRow.getItem();
-                if (stringObject instanceof Gtk.StringObject) {
-                    this.boundItems.delete(stringObject.getString());
-                }
-            }
-        }
-    }
-    onTeardown(_listItem, ptr) {
-        this.expanders.delete(ptr);
-        this.setupComplete.delete(ptr);
-        this.pendingBinds.delete(ptr);
-    }
-    processPendingBind(ptr) {
-        const pending = this.pendingBinds.get(ptr);
-        if (!pending)
-            return;
-        this.pendingBinds.delete(ptr);
-        const fiberRoot = this.fiberRoots.get(ptr);
-        if (fiberRoot) {
-            this.renderBind(ptr, pending.expander, pending.treeListRow, pending.id, fiberRoot);
-        }
-    }
-    renderBind(ptr, expander, treeListRow, id, fiberRoot) {
-        const itemData = this.getStore().getItem(id);
-        if (itemData) {
-            if (itemData.indentForDepth !== undefined) {
-                expander.setIndentForDepth(itemData.indentForDepth);
-            }
-            if (itemData.indentForIcon !== undefined) {
-                expander.setIndentForIcon(itemData.indentForIcon);
-            }
-            if (itemData.hideExpander !== undefined) {
-                expander.setHideExpander(itemData.hideExpander);
-            }
-        }
-        const element = this.renderFn?.(itemData?.value ?? null, treeListRow);
-        reconciler.getInstance().updateContainer(element, fiberRoot, null, () => {
-            if (this.tornDown.has(ptr))
-                return;
-            if (this.estimatedItemHeight !== null)
-                return;
-            const currentExpander = this.expanders.get(ptr);
-            if (!currentExpander)
-                return;
-            const box = currentExpander.getChild();
-            if (box) {
-                this.clearBoxSizeRequest(box);
-            }
-        });
-    }
-}

package/dist/nodes/internal/utils.d.ts

@@ -1,12 +0,0 @@
-import type { Container, ContainerClass, Props } from "../../types.js";
-type AnyClass = new (...args: any[]) => any;
-export declare const matchesAnyClass: (classes: readonly AnyClass[], containerOrClass?: Container | ContainerClass | null) => boolean;
-export declare const matchesInterface: (methods: readonly string[], containerOrClass?: Container | ContainerClass | null) => boolean;
-export declare const filterProps: (props: Props, excludeKeys: readonly string[]) => Props;
-export declare const resolvePropMeta: (instance: Container, key: string) => [string | null, string] | null;
-export declare const resolveSignal: (instance: Container, signalName: string) => boolean;
-export declare const propNameToSignalName: (propName: string) => string;
-export declare const hasChanged: <T>(oldProps: T | null, newProps: T, key: keyof T) => boolean;
-export declare const shallowArrayEqual: <T extends Record<string, unknown>>(a: T[], b: T[]) => boolean;
-export declare const primitiveArrayEqual: <T extends string | number | boolean>(a: T[] | null | undefined, b: T[] | null | undefined) => boolean;
-export {};

package/dist/nodes/internal/utils.js

@@ -1,92 +0,0 @@
-import { PROPS, SIGNALS } from "../../generated/internal.js";
-export const matchesAnyClass = (classes, containerOrClass) => {
-    if (!containerOrClass) {
-        return false;
-    }
-    return classes.some((cls) => containerOrClass instanceof cls ||
-        containerOrClass === cls ||
-        Object.prototype.isPrototypeOf.call(cls, containerOrClass));
-};
-export const matchesInterface = (methods, containerOrClass) => {
-    if (!containerOrClass) {
-        return false;
-    }
-    const proto = typeof containerOrClass === "function" ? containerOrClass.prototype : containerOrClass;
-    return methods.every((method) => method in proto);
-};
-export const filterProps = (props, excludeKeys) => {
-    const result = {};
-    for (const key of Object.keys(props)) {
-        if (!excludeKeys.includes(key)) {
-            result[key] = props[key];
-        }
-    }
-    return result;
-};
-const walkPrototypeChain = (instance, lookup) => {
-    // biome-ignore lint/complexity/noBannedTypes: Walking prototype chain requires Function type
-    let current = instance.constructor;
-    while (current) {
-        const typeName = current.glibTypeName;
-        if (typeName) {
-            const result = lookup(typeName);
-            if (result !== null) {
-                return result;
-            }
-        }
-        const prototype = Object.getPrototypeOf(current.prototype);
-        current = prototype?.constructor ?? null;
-        if (current === Object || current === Function) {
-            break;
-        }
-    }
-    return null;
-};
-export const resolvePropMeta = (instance, key) => walkPrototypeChain(instance, (typeName) => PROPS[typeName]?.[key] ?? null);
-export const resolveSignal = (instance, signalName) => {
-    if (signalName === "notify")
-        return true;
-    return walkPrototypeChain(instance, (typeName) => (SIGNALS[typeName]?.has(signalName) ? true : null)) ?? false;
-};
-export const propNameToSignalName = (propName) => {
-    if (!propName.startsWith("on"))
-        return propName;
-    return propName
-        .slice(2)
-        .replace(/([A-Z])/g, "-$1")
-        .toLowerCase()
-        .replace(/^-/, "");
-};
-export const hasChanged = (oldProps, newProps, key) => !oldProps || oldProps[key] !== newProps[key];
-export const shallowArrayEqual = (a, b) => {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        const itemA = a[i];
-        const itemB = b[i];
-        if (!itemA || !itemB)
-            return false;
-        const keysA = Object.keys(itemA);
-        const keysB = Object.keys(itemB);
-        if (keysA.length !== keysB.length)
-            return false;
-        for (const key of keysA) {
-            if (itemA[key] !== itemB[key])
-                return false;
-        }
-    }
-    return true;
-};
-export const primitiveArrayEqual = (a, b) => {
-    if (a === b)
-        return true;
-    if (!a || !b)
-        return false;
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-};

package/dist/nodes/models/tree-list.d.ts

@@ -1,28 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { Node } from "../../node.js";
-import type { Container } from "../../types.js";
-import { TreeStore } from "../internal/tree-store.js";
-import { VirtualNode } from "../virtual.js";
-export type TreeListProps = {
-    autoexpand?: boolean;
-    selectionMode?: Gtk.SelectionMode;
-    selected?: string[];
-    onSelectionChanged?: (ids: string[]) => void;
-};
-export declare class TreeList extends VirtualNode<TreeListProps> {
-    private store;
-    private treeListModel;
-    private selectionManager;
-    constructor(props: TreeListProps | undefined, rootContainer: Container);
-    private createChildModel;
-    getStore(): TreeStore;
-    getTreeListModel(): Gtk.TreeListModel;
-    getSelectionModel(): Gtk.NoSelection | Gtk.SingleSelection | Gtk.MultiSelection;
-    appendChild(child: Node): void;
-    private addItemWithChildren;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
-    updateProps(oldProps: TreeListProps | null, newProps: TreeListProps): void;
-    private getSelection;
-    private resolveSelectionIndices;
-}

package/dist/nodes/models/tree-list.js

@@ -1,113 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import { SelectionModelManager } from "../internal/selection-model.js";
-import { TreeStore } from "../internal/tree-store.js";
-import { createTreeItemData, TreeListItemNode } from "../tree-list-item.js";
-import { VirtualNode } from "../virtual.js";
-export class TreeList extends VirtualNode {
-    store;
-    treeListModel;
-    selectionManager;
-    constructor(props = {}, rootContainer) {
-        super("", {}, undefined, rootContainer);
-        this.store = new TreeStore();
-        this.treeListModel = new Gtk.TreeListModel(this.store.getRootModel(), false, props.autoexpand ?? false, (item) => this.createChildModel(item));
-        this.selectionManager = new SelectionModelManager({ owner: this, signalStore: this.signalStore, ...props }, this.treeListModel, () => this.getSelection(), (ids) => this.resolveSelectionIndices(ids), () => this.treeListModel.getNItems());
-    }
-    createChildModel(item) {
-        if (!(item instanceof Gtk.StringObject))
-            return null;
-        const parentId = item.getString();
-        return this.store.getChildrenModel(parentId);
-    }
-    getStore() {
-        return this.store;
-    }
-    getTreeListModel() {
-        return this.treeListModel;
-    }
-    getSelectionModel() {
-        return this.selectionManager.getSelectionModel();
-    }
-    appendChild(child) {
-        if (!(child instanceof TreeListItemNode)) {
-            return;
-        }
-        if (!child.props.id) {
-            throw new Error("Cannot append 'TreeListItem' to 'TreeList': missing required 'id' prop");
-        }
-        child.setStore(this.store);
-        this.addItemWithChildren(child);
-    }
-    addItemWithChildren(node, parentId) {
-        const id = node.props.id;
-        if (id === undefined)
-            return;
-        for (const child of node.getChildNodes()) {
-            this.addItemWithChildren(child, id);
-        }
-        this.store.addItem(id, createTreeItemData(node.props), parentId);
-    }
-    insertBefore(child, before) {
-        if (!(child instanceof TreeListItemNode) || !(before instanceof TreeListItemNode)) {
-            return;
-        }
-        if (!child.props.id) {
-            throw new Error("Cannot insert 'TreeListItem' into 'TreeList': missing required 'id' prop");
-        }
-        if (!before.props.id) {
-            throw new Error("Cannot insert 'TreeListItem' into 'TreeList': 'before' node missing required 'id' prop");
-        }
-        const id = child.props.id;
-        const beforeId = before.props.id;
-        child.setStore(this.store);
-        this.store.insertItemBefore(id, beforeId, createTreeItemData(child.props));
-    }
-    removeChild(child) {
-        if (!(child instanceof TreeListItemNode)) {
-            return;
-        }
-        if (!child.props.id) {
-            throw new Error("Cannot remove 'TreeListItem' from 'TreeList': missing required 'id' prop");
-        }
-        const id = child.props.id;
-        this.store.removeItem(id);
-        child.setStore(null);
-    }
-    updateProps(oldProps, newProps) {
-        super.updateProps(oldProps, newProps);
-        if (!oldProps || oldProps.autoexpand !== newProps.autoexpand) {
-            this.treeListModel.setAutoexpand(newProps.autoexpand ?? false);
-        }
-        this.selectionManager.update(oldProps ? { owner: this, signalStore: this.signalStore, ...oldProps } : null, { owner: this, signalStore: this.signalStore, ...newProps }, this.treeListModel);
-    }
-    getSelection() {
-        const selection = this.selectionManager.getSelectionModel().getSelection();
-        const size = selection.getSize();
-        const ids = [];
-        for (let i = 0; i < size; i++) {
-            const index = selection.getNth(i);
-            const row = this.treeListModel.getRow(index);
-            if (!row)
-                continue;
-            const item = row.getItem();
-            if (item instanceof Gtk.StringObject) {
-                ids.push(item.getString());
-            }
-        }
-        return ids;
-    }
-    resolveSelectionIndices(ids) {
-        const nItems = this.treeListModel.getNItems();
-        const selected = new Gtk.Bitset();
-        for (let i = 0; i < nItems; i++) {
-            const row = this.treeListModel.getRow(i);
-            if (!row)
-                continue;
-            const item = row.getItem();
-            if (item instanceof Gtk.StringObject && ids.includes(item.getString())) {
-                selected.add(i);
-            }
-        }
-        return selected;
-    }
-}

package/dist/nodes/pack-child.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/nodes/pack-child.js

@@ -1,30 +0,0 @@
-import { PACK_INTERFACE_METHODS } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
-import { VirtualContainerNode } from "./abstract/virtual-container.js";
-import { matchesInterface } from "./internal/utils.js";
-class PackStartNode extends VirtualContainerNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "PackStart";
-    }
-    canBeChildOf(parent) {
-        return matchesInterface(PACK_INTERFACE_METHODS, parent.container);
-    }
-    attachChild(parent, widget) {
-        parent.packStart(widget);
-    }
-}
-class PackEndNode extends VirtualContainerNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "PackEnd";
-    }
-    canBeChildOf(parent) {
-        return matchesInterface(PACK_INTERFACE_METHODS, parent.container);
-    }
-    attachChild(parent, widget) {
-        parent.packEnd(widget);
-    }
-}
-registerNodeClass(PackStartNode);
-registerNodeClass(PackEndNode);

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

@@ -1,9 +0,0 @@
-import type { StringListItemProps } from "../jsx.js";
-import type { SimpleListStore } from "./internal/simple-list-store.js";
-import { ListItemNode } from "./list-item.js";
-type Props = Partial<StringListItemProps>;
-export declare class SimpleListItemNode extends ListItemNode<SimpleListStore, Props> {
-    static priority: number;
-    static matches(type: string): boolean;
-}
-export {};

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

@@ -1,9 +0,0 @@
-import { registerNodeClass } from "../registry.js";
-import { ListItemNode } from "./list-item.js";
-export class SimpleListItemNode extends ListItemNode {
-    static priority = -1;
-    static matches(type) {
-        return type === "SimpleListItem";
-    }
-}
-registerNodeClass(SimpleListItemNode);

package/dist/nodes/simple-list-view.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/nodes/simple-list-view.js

@@ -1,74 +0,0 @@
-import { DROP_DOWN_CLASSES } from "../generated/internal.js";
-import { registerNodeClass } from "../registry.js";
-import { SimpleListStore } from "./internal/simple-list-store.js";
-import { filterProps, matchesAnyClass } from "./internal/utils.js";
-import { SimpleListItemNode } from "./simple-list-item.js";
-import { WidgetNode } from "./widget.js";
-const PROP_NAMES = ["selectedId", "onSelectionChanged"];
-class SimpleListViewNode extends WidgetNode {
-    static priority = -1;
-    static matches(_type, containerOrClass) {
-        return matchesAnyClass(DROP_DOWN_CLASSES, containerOrClass);
-    }
-    store = new SimpleListStore();
-    constructor(typeName, props, container, rootContainer) {
-        super(typeName, props, container, rootContainer);
-        this.container.setModel(this.store.getModel());
-    }
-    updateProps(oldProps, newProps) {
-        if (!oldProps || oldProps.onSelectionChanged !== newProps.onSelectionChanged) {
-            const onSelectionChanged = newProps.onSelectionChanged;
-            const handleSelectionChange = onSelectionChanged
-                ? () => {
-                    const selectedIndex = this.container.getSelected();
-                    const id = this.store.getIdAtIndex(selectedIndex);
-                    if (id !== null) {
-                        onSelectionChanged(id);
-                    }
-                }
-                : undefined;
-            this.signalStore.set(this, this.container, "notify::selected", handleSelectionChange);
-        }
-        if (!oldProps || oldProps.selectedId !== newProps.selectedId) {
-            const index = newProps.selectedId !== undefined ? this.store.getIndexById(newProps.selectedId) : null;
-            if (index !== null) {
-                this.container.setSelected(index);
-            }
-        }
-        super.updateProps(oldProps ? filterProps(oldProps, PROP_NAMES) : null, filterProps(newProps, PROP_NAMES));
-    }
-    appendChild(child) {
-        if (!(child instanceof SimpleListItemNode)) {
-            throw new Error(`Cannot append '${child.typeName}' to 'DropDown': expected x.SimpleListItem`);
-        }
-        const { id, value } = child.props;
-        if (!id || value === undefined) {
-            throw new Error("Expected 'id' and 'value' props to be present on SimpleListItem");
-        }
-        child.setStore(this.store);
-        this.store.addItem(id, value);
-    }
-    insertBefore(child, before) {
-        if (!(child instanceof SimpleListItemNode) || !(before instanceof SimpleListItemNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' into 'DropDown': expected x.SimpleListItem`);
-        }
-        const { id, value } = child.props;
-        const beforeId = before.props.id;
-        if (!id || value === undefined || !beforeId) {
-            throw new Error("Expected 'id' and 'value' props to be present on SimpleListItem");
-        }
-        child.setStore(this.store);
-        this.store.insertItemBefore(id, beforeId, value);
-    }
-    removeChild(child) {
-        if (!(child instanceof SimpleListItemNode)) {
-            throw new Error(`Cannot remove '${child.typeName}' from 'DropDown': expected x.SimpleListItem`);
-        }
-        const { id } = child.props;
-        if (!id) {
-            throw new Error("Expected 'id' prop to be present on SimpleListItem");
-        }
-        this.store.removeItem(id);
-    }
-}
-registerNodeClass(SimpleListViewNode);

package/dist/nodes/toolbar-child.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/nodes/toolbar-child.js

@@ -1,30 +0,0 @@
-import { registerNodeClass } from "../registry.js";
-import { VirtualContainerNode } from "./abstract/virtual-container.js";
-import { matchesInterface } from "./internal/utils.js";
-const TOOLBAR_INTERFACE_METHODS = ["addTopBar", "addBottomBar", "remove"];
-class ToolbarTopNode extends VirtualContainerNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "ToolbarTop";
-    }
-    canBeChildOf(parent) {
-        return matchesInterface(TOOLBAR_INTERFACE_METHODS, parent.container);
-    }
-    attachChild(parent, widget) {
-        parent.addTopBar(widget);
-    }
-}
-class ToolbarBottomNode extends VirtualContainerNode {
-    static priority = 1;
-    static matches(type) {
-        return type === "ToolbarBottom";
-    }
-    canBeChildOf(parent) {
-        return matchesInterface(TOOLBAR_INTERFACE_METHODS, parent.container);
-    }
-    attachChild(parent, widget) {
-        parent.addBottomBar(widget);
-    }
-}
-registerNodeClass(ToolbarTopNode);
-registerNodeClass(ToolbarBottomNode);

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

@@ -1,22 +0,0 @@
-import type { TreeListItemProps } from "../jsx.js";
-import type { Node } from "../node.js";
-import type { TreeItemData, TreeStore } from "./internal/tree-store.js";
-import { VirtualNode } from "./virtual.js";
-type Props = Partial<TreeListItemProps>;
-export declare const createTreeItemData: (props: Props) => TreeItemData;
-export declare class TreeListItemNode extends VirtualNode<Props> {
-    static priority: number;
-    private store;
-    private parentItemId;
-    private childNodes;
-    static matches(type: string): boolean;
-    setStore(store: TreeStore | null): void;
-    getChildNodes(): readonly TreeListItemNode[];
-    setParentItemId(parentId: string | null): void;
-    getParentItemId(): string | null;
-    appendChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
-    updateProps(oldProps: Props | null, newProps: Props): void;
-}
-export {};