@gtkx/react 0.9.4 → 0.10.0

package/dist/nodes/overlay.js

@@ -1,50 +0,0 @@
-import { Node } from "../node.js";
-export class OverlayNode extends Node {
-    static matches(type) {
-        return type === "Overlay" || type === "Overlay.Root";
-    }
-    mainChild = null;
-    overlayChildren = [];
-    attachChild(childWidget) {
-        if (this.mainChild === null) {
-            this.mainChild = childWidget;
-            this.widget.setChild(childWidget);
-        }
-        else {
-            this.overlayChildren.push(childWidget);
-            this.widget.addOverlay(childWidget);
-        }
-    }
-    insertChildBefore(childWidget, beforeWidget) {
-        if (this.mainChild === null) {
-            this.mainChild = childWidget;
-            this.widget.setChild(childWidget);
-            return;
-        }
-        if (this.mainChild === beforeWidget) {
-            this.overlayChildren.unshift(childWidget);
-            this.widget.addOverlay(childWidget);
-            return;
-        }
-        const beforeIndex = this.overlayChildren.indexOf(beforeWidget);
-        if (beforeIndex === -1) {
-            this.attachChild(childWidget);
-            return;
-        }
-        this.overlayChildren.splice(beforeIndex, 0, childWidget);
-        this.widget.addOverlay(childWidget);
-    }
-    detachChild(childWidget) {
-        if (this.mainChild === childWidget) {
-            this.widget.setChild(undefined);
-            this.mainChild = null;
-        }
-        else {
-            const index = this.overlayChildren.indexOf(childWidget);
-            if (index !== -1) {
-                this.overlayChildren.splice(index, 1);
-                this.widget.removeOverlay(childWidget);
-            }
-        }
-    }
-}

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

@@ -1,31 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { ChildContainer, StackPageContainer, StackPageProps } from "../containers.js";
-import type { Props } from "../factory.js";
-import type { Node } from "../node.js";
-import { Node as NodeClass } from "../node.js";
-import { type StackPageLike } from "./stack-page-props.js";
-type StackWidget = Gtk.Widget & {
-    getChildByName(name: string): Gtk.Widget | null;
-    setVisibleChild(child: Gtk.Widget): void;
-    remove(child: Gtk.Widget): void;
-    getPage(child: Gtk.Widget): StackPageLike;
-};
-export declare abstract class PagedStackNode<T extends StackWidget> extends NodeClass<T> implements StackPageContainer, ChildContainer {
-    static consumedPropNames: string[];
-    private pendingVisibleChildName;
-    abstract addStackPage(child: Gtk.Widget, props: StackPageProps): void;
-    protected abstract addChildToWidget(child: Gtk.Widget): void;
-    protected applyPendingVisibleChild(): void;
-    insertStackPageBefore(child: Gtk.Widget, props: StackPageProps, _beforeChild: Gtk.Widget): void;
-    removeStackPage(child: Gtk.Widget): void;
-    updateStackPageProps(child: Gtk.Widget, props: StackPageProps): void;
-    attachChild(child: Gtk.Widget): void;
-    insertChildBefore(child: Gtk.Widget, _before: Gtk.Widget): void;
-    detachChild(child: Gtk.Widget): void;
-    private setVisibleChildOrDefer;
-    appendChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
-    updateProps(oldProps: Props, newProps: Props): void;
-}
-export {};

package/dist/nodes/paged-stack.js

@@ -1,95 +0,0 @@
-import { Node as NodeClass } from "../node.js";
-import { StackPageNode } from "./stack.js";
-import { applyStackPageProps } from "./stack-page-props.js";
-export class PagedStackNode extends NodeClass {
-    static consumedPropNames = ["visibleChildName"];
-    pendingVisibleChildName = null;
-    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 page = this.widget.getPage(child);
-        applyStackPageProps(page, props);
-    }
-    attachChild(child) {
-        this.addChildToWidget(child);
-    }
-    insertChildBefore(child, _before) {
-        this.addChildToWidget(child);
-    }
-    detachChild(child) {
-        this.widget.remove(child);
-    }
-    setVisibleChildOrDefer(name) {
-        const child = this.widget.getChildByName(name);
-        if (child) {
-            this.widget.setVisibleChild(child);
-            this.pendingVisibleChildName = null;
-        }
-        else {
-            this.pendingVisibleChildName = name;
-        }
-    }
-    appendChild(child) {
-        if (child instanceof StackPageNode) {
-            child.parent = this;
-            const childWidget = child.getChildWidget();
-            const props = child.getSlotProps();
-            if (childWidget) {
-                this.addStackPage(childWidget, props);
-                child.setParentContainer(this);
-            }
-            return;
-        }
-        super.appendChild(child);
-    }
-    insertBefore(child, before) {
-        if (child instanceof StackPageNode) {
-            child.parent = this;
-            const childWidget = child.getChildWidget();
-            const props = child.getSlotProps();
-            if (childWidget) {
-                const beforeWidget = child.getBeforeWidget(before);
-                if (beforeWidget) {
-                    this.insertStackPageBefore(childWidget, props, beforeWidget);
-                }
-                else {
-                    this.addStackPage(childWidget, props);
-                }
-                child.setParentContainer(this);
-            }
-            return;
-        }
-        super.insertBefore(child, before);
-    }
-    removeChild(child) {
-        if (child instanceof StackPageNode) {
-            const childWidget = child.getChildWidget();
-            if (childWidget) {
-                this.removeStackPage(childWidget);
-            }
-            child.unmount();
-            child.parent = null;
-            return;
-        }
-        super.removeChild(child);
-    }
-    updateProps(oldProps, newProps) {
-        if (newProps.visibleChildName !== undefined) {
-            this.setVisibleChildOrDefer(newProps.visibleChildName);
-        }
-        super.updateProps(oldProps, newProps);
-    }
-}

package/dist/nodes/root.d.ts

@@ -1,8 +0,0 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { Node } from "../node.js";
-export declare const ROOT_NODE_CONTAINER: unique symbol;
-export declare class RootNode extends Node<never> {
-    static matches(_type: string, widget?: Gtk.Widget | typeof ROOT_NODE_CONTAINER): boolean;
-    protected isVirtual(): boolean;
-    constructor();
-}

package/dist/nodes/root.js

@@ -1,13 +0,0 @@
-import { Node } from "../node.js";
-export const ROOT_NODE_CONTAINER = Symbol.for("ROOT_NODE_CONTAINER");
-export class RootNode extends Node {
-    static matches(_type, widget) {
-        return widget === ROOT_NODE_CONTAINER;
-    }
-    isVirtual() {
-        return true;
-    }
-    constructor() {
-        super("");
-    }
-}

package/dist/nodes/selectable-list.d.ts

@@ -1,45 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { ItemContainer } from "../containers.js";
-import type { Props } from "../factory.js";
-import type { Node } from "../node.js";
-import { Node as NodeClass } from "../node.js";
-export type SelectableListState = {
-    itemsById: Map<string, unknown>;
-    itemOrder: string[];
-    committedOrder: string[];
-    stringList: Gtk.StringList;
-    selectionModel: Gtk.SingleSelection | Gtk.MultiSelection;
-    selectionMode: Gtk.SelectionMode;
-    selected: string[];
-    onSelectionChanged?: (ids: string[]) => void;
-    selectionHandlerId: number | null;
-    needsSync: boolean;
-    needsInitialSelection: boolean;
-};
-type SelectableListWidget = Gtk.Widget & {
-    setModel(model: Gtk.SelectionModel): void;
-};
-export declare abstract class SelectableListNode<T extends SelectableListWidget, S extends SelectableListState> extends NodeClass<T, S> implements ItemContainer<unknown> {
-    appendChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
-    protected initializeSelectionState(props: Props): SelectableListState;
-    protected applySelectionModel(): void;
-    protected cleanupSelection(): void;
-    protected updateSelectionProps(oldProps: Props, newProps: Props): void;
-    private recreateSelectionModel;
-    getItems(): unknown[];
-    getItemById(id: string): unknown;
-    addItem(id: string, data: unknown): void;
-    insertItemBefore(id: string, data: unknown, beforeId: string): void;
-    removeItem(id: string): void;
-    updateItem(id: string, data: unknown): void;
-    protected scheduleSync(): void;
-    protected syncModel: () => void;
-    protected applyInitialSelection(): void;
-    protected applySelection(ids: string[]): void;
-    protected getSelectedIds(): string[];
-    protected connectSelectionHandler(): void;
-    protected disconnectSelectionHandler(): void;
-}
-export {};

package/dist/nodes/selectable-list.js

@@ -1,260 +0,0 @@
-import { getNativeObject } from "@gtkx/ffi";
-import * as Gio from "@gtkx/ffi/gio";
-import * as GObject from "@gtkx/ffi/gobject";
-import * as Gtk from "@gtkx/ffi/gtk";
-import { scheduleFlush } from "../batch.js";
-import { Node as NodeClass } from "../node.js";
-import { getCallbackChange } from "../props.js";
-import { VirtualItemNode } from "./virtual-item.js";
-export class SelectableListNode extends NodeClass {
-    appendChild(child) {
-        if (child instanceof VirtualItemNode) {
-            child.parent = this;
-            child.addToContainer(this);
-            child.setParentContainer(this);
-            return;
-        }
-        super.appendChild(child);
-    }
-    insertBefore(child, before) {
-        if (child instanceof VirtualItemNode) {
-            child.parent = this;
-            if (before instanceof VirtualItemNode) {
-                child.insertBeforeInContainer(this, before.getId());
-            }
-            else {
-                child.addToContainer(this);
-            }
-            child.setParentContainer(this);
-            return;
-        }
-        super.insertBefore(child, before);
-    }
-    removeChild(child) {
-        if (child instanceof VirtualItemNode) {
-            child.unmount();
-            child.parent = null;
-            return;
-        }
-        super.removeChild(child);
-    }
-    initializeSelectionState(props) {
-        const selectionMode = props.selectionMode ?? Gtk.SelectionMode.SINGLE;
-        const stringList = new Gtk.StringList([]);
-        const listModel = getNativeObject(stringList.id, Gio.ListModel) ?? undefined;
-        const selectionModel = selectionMode === Gtk.SelectionMode.MULTIPLE
-            ? new Gtk.MultiSelection(listModel)
-            : new Gtk.SingleSelection(listModel);
-        if (selectionModel instanceof Gtk.SingleSelection) {
-            selectionModel.setAutoselect(false);
-            selectionModel.setCanUnselect(true);
-        }
-        return {
-            itemsById: new Map(),
-            itemOrder: [],
-            committedOrder: [],
-            stringList,
-            selectionModel,
-            selectionMode,
-            selected: props.selected ?? [],
-            onSelectionChanged: props.onSelectionChanged,
-            selectionHandlerId: null,
-            needsSync: false,
-            needsInitialSelection: true,
-        };
-    }
-    applySelectionModel() {
-        this.widget.setModel(this.state.selectionModel);
-    }
-    cleanupSelection() {
-        this.disconnectSelectionHandler();
-    }
-    updateSelectionProps(oldProps, newProps) {
-        const oldSelectionMode = oldProps.selectionMode;
-        const newSelectionMode = newProps.selectionMode;
-        const effectiveOldMode = oldSelectionMode ?? Gtk.SelectionMode.SINGLE;
-        const effectiveNewMode = newSelectionMode ?? Gtk.SelectionMode.SINGLE;
-        if (effectiveOldMode !== effectiveNewMode) {
-            this.recreateSelectionModel(effectiveNewMode);
-        }
-        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.disconnectSelectionHandler();
-            }
-            else if (change.action === "connect") {
-                this.connectSelectionHandler();
-            }
-        }
-        const oldSelected = oldProps.selected;
-        const newSelected = newProps.selected;
-        if (oldSelected !== newSelected && newSelected !== undefined) {
-            this.state.selected = newSelected;
-            this.applySelection(newSelected);
-        }
-    }
-    recreateSelectionModel(newSelectionMode) {
-        const currentSelection = this.getSelectedIds();
-        const hadHandler = this.state.selectionHandlerId !== null;
-        this.disconnectSelectionHandler();
-        const listModel = getNativeObject(this.state.stringList.id, Gio.ListModel) ?? undefined;
-        const newSelectionModel = newSelectionMode === Gtk.SelectionMode.MULTIPLE
-            ? new Gtk.MultiSelection(listModel)
-            : new Gtk.SingleSelection(listModel);
-        if (newSelectionModel instanceof Gtk.SingleSelection) {
-            newSelectionModel.setAutoselect(false);
-            newSelectionModel.setCanUnselect(true);
-        }
-        this.state.selectionModel = newSelectionModel;
-        this.state.selectionMode = newSelectionMode;
-        this.applySelectionModel();
-        this.applySelection(currentSelection);
-        if (hadHandler && this.state.onSelectionChanged) {
-            this.connectSelectionHandler();
-        }
-    }
-    getItems() {
-        return this.state.itemOrder.map((id) => this.state.itemsById.get(id));
-    }
-    getItemById(id) {
-        return this.state.itemsById.get(id);
-    }
-    addItem(id, data) {
-        this.state.itemsById.set(id, data);
-        const existingIndex = this.state.itemOrder.indexOf(id);
-        if (existingIndex !== -1) {
-            this.state.itemOrder.splice(existingIndex, 1);
-        }
-        this.state.itemOrder.push(id);
-        this.scheduleSync();
-    }
-    insertItemBefore(id, data, beforeId) {
-        this.state.itemsById.set(id, data);
-        const existingIndex = this.state.itemOrder.indexOf(id);
-        if (existingIndex !== -1) {
-            this.state.itemOrder.splice(existingIndex, 1);
-        }
-        const beforeIndex = this.state.itemOrder.indexOf(beforeId);
-        if (beforeIndex === -1) {
-            this.state.itemOrder.push(id);
-        }
-        else {
-            this.state.itemOrder.splice(beforeIndex, 0, id);
-        }
-        this.scheduleSync();
-    }
-    removeItem(id) {
-        const index = this.state.itemOrder.indexOf(id);
-        if (index !== -1) {
-            this.state.itemOrder.splice(index, 1);
-            this.state.itemsById.delete(id);
-            this.scheduleSync();
-        }
-    }
-    updateItem(id, data) {
-        if (this.state.itemsById.has(id)) {
-            this.state.itemsById.set(id, data);
-        }
-    }
-    scheduleSync() {
-        if (!this.state.needsSync) {
-            this.state.needsSync = true;
-            scheduleFlush(this.syncModel);
-        }
-    }
-    syncModel = () => {
-        if (!this.state.needsSync)
-            return;
-        this.state.needsSync = false;
-        const oldOrder = this.state.committedOrder;
-        const newOrder = this.state.itemOrder;
-        let firstDiff = 0;
-        const minLen = Math.min(oldOrder.length, newOrder.length);
-        while (firstDiff < minLen && oldOrder[firstDiff] === newOrder[firstDiff]) {
-            firstDiff++;
-        }
-        let oldEndOffset = 0;
-        let newEndOffset = 0;
-        while (oldEndOffset < oldOrder.length - firstDiff &&
-            newEndOffset < newOrder.length - firstDiff &&
-            oldOrder[oldOrder.length - 1 - oldEndOffset] === newOrder[newOrder.length - 1 - newEndOffset]) {
-            oldEndOffset++;
-            newEndOffset++;
-        }
-        const removeCount = oldOrder.length - firstDiff - oldEndOffset;
-        const addItems = newOrder.slice(firstDiff, newOrder.length - newEndOffset);
-        if (removeCount > 0 || addItems.length > 0) {
-            this.state.stringList.splice(firstDiff, removeCount, addItems);
-        }
-        this.state.committedOrder = [...newOrder];
-        if (this.state.needsInitialSelection && this.state.itemOrder.length > 0) {
-            this.state.needsInitialSelection = false;
-            queueMicrotask(() => {
-                if (this.hasParent()) {
-                    this.applyInitialSelection();
-                }
-            });
-        }
-    };
-    applyInitialSelection() {
-        this.applySelection(this.state.selected);
-        if (this.state.onSelectionChanged) {
-            this.connectSelectionHandler();
-            this.state.onSelectionChanged(this.getSelectedIds());
-        }
-    }
-    applySelection(ids) {
-        if (this.state.selectionMode === Gtk.SelectionMode.MULTIPLE) {
-            const multiSelection = this.state.selectionModel;
-            multiSelection.unselectAll();
-            for (const id of ids) {
-                const index = this.state.itemOrder.indexOf(id);
-                if (index !== -1) {
-                    multiSelection.selectItem(index, false);
-                }
-            }
-        }
-        else {
-            const singleSelection = this.state.selectionModel;
-            const firstId = ids[0];
-            if (firstId !== undefined) {
-                const index = this.state.itemOrder.indexOf(firstId);
-                if (index !== -1) {
-                    singleSelection.setSelected(index);
-                }
-            }
-            else {
-                singleSelection.setSelected(Gtk.INVALID_LIST_POSITION);
-            }
-        }
-    }
-    getSelectedIds() {
-        const selection = this.state.selectionModel.getSelection();
-        const count = Number(selection.getSize());
-        const selectedIds = [];
-        for (let i = 0; i < count; i++) {
-            const position = selection.getNth(i);
-            const id = this.state.itemOrder[position];
-            if (id !== undefined) {
-                selectedIds.push(id);
-            }
-        }
-        return selectedIds;
-    }
-    connectSelectionHandler() {
-        if (this.state.selectionHandlerId !== null)
-            return;
-        this.state.selectionHandlerId = this.state.selectionModel.connect("selection-changed", () => {
-            this.state.onSelectionChanged?.(this.getSelectedIds());
-        });
-    }
-    disconnectSelectionHandler() {
-        if (this.state.selectionHandlerId !== null) {
-            GObject.signalHandlerDisconnect(this.state.selectionModel, this.state.selectionHandlerId);
-            this.state.selectionHandlerId = null;
-        }
-    }
-}

package/dist/nodes/stack-page-props.d.ts

@@ -1,11 +0,0 @@
-import type { StackPageProps } from "../containers.js";
-export type StackPageLike = {
-    setName(name: string): void;
-    setTitle(title: string): void;
-    setIconName(iconName: string): void;
-    setNeedsAttention(needsAttention: boolean): void;
-    setVisible(visible: boolean): void;
-    setUseUnderline(useUnderline: boolean): void;
-    setBadgeNumber?(badgeNumber: number): void;
-};
-export declare function applyStackPageProps(page: StackPageLike, props: StackPageProps): void;

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

@@ -1,23 +0,0 @@
-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/string-list-container.d.ts

@@ -1,34 +0,0 @@
-import * as Gio from "@gtkx/ffi/gio";
-import type * as Gtk from "@gtkx/ffi/gtk";
-import type { StringListContainer } from "../containers.js";
-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";
-type StringListContainerState = {
-    store: StringListStore;
-    onSelectionChanged?: (id: string) => void;
-    initialSelection?: string;
-    hasAppliedInitialSelection: boolean;
-};
-type StringListWidget = Gtk.Widget & {
-    setModel(model?: Gio.ListModel): void;
-    getSelected(): number;
-    setSelected(position: number): void;
-};
-export declare abstract class StringListContainerNode<T extends StringListWidget> extends NodeClass<T, StringListContainerState> implements StringListContainer {
-    static consumedPropNames: string[];
-    appendChild(child: Node): void;
-    insertBefore(child: Node, before: Node): void;
-    removeChild(child: Node): void;
-    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 {};