@gtkx/react 0.14.0 → 0.16.0

package/dist/nodes/animation/animation-node.js

@@ -0,0 +1,126 @@
+import { registerNodeClass } from "../../registry.js";
+import { CommitPriority, scheduleAfterCommit } from "../../scheduler.js";
+import { VirtualSingleChildNode } from "../abstract/virtual-single-child.js";
+import { attachChild, detachChild, getAttachmentStrategy } from "../internal/child-attachment.js";
+import { isRemovable } from "../internal/predicates.js";
+import { WidgetNode } from "../widget.js";
+import { AnimationController } from "./animation-controller.js";
+class AnimationNode extends VirtualSingleChildNode {
+    static priority = 2;
+    controller = new AnimationController();
+    hasAppliedInitial = false;
+    hasStartedAnimation = false;
+    static matches(type) {
+        return type === "Animation";
+    }
+    appendChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot append '${child.typeName}' to 'x.Animation': expected Widget`);
+        }
+        const oldChild = this.child;
+        this.child = child.container;
+        scheduleAfterCommit(() => {
+            if (this.parent) {
+                this.onChildChange(oldChild);
+            }
+        }, CommitPriority.NORMAL);
+    }
+    removeChild(child) {
+        if (!(child instanceof WidgetNode)) {
+            throw new Error(`Cannot remove '${child.typeName}' from 'x.Animation': expected Widget`);
+        }
+        const oldChild = this.child;
+        scheduleAfterCommit(() => {
+            if (oldChild === this.child) {
+                this.child = null;
+                this.controller.setWidget(null);
+            }
+            if (this.parent && oldChild) {
+                this.onChildChange(oldChild);
+            }
+        }, CommitPriority.HIGH);
+    }
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps, newProps);
+        const animateChanged = !shallowObjectEqual(oldProps?.animate, newProps.animate);
+        if (animateChanged) {
+            this.hasStartedAnimation = false;
+        }
+        if (this.child) {
+            this.controller.setWidget(this.child);
+            if (!this.hasAppliedInitial && newProps.initial) {
+                this.controller.applyImmediate(newProps.initial);
+                this.hasAppliedInitial = true;
+            }
+            if (!this.hasStartedAnimation && newProps.animate) {
+                this.hasStartedAnimation = true;
+                this.startAnimation();
+            }
+        }
+    }
+    unmount() {
+        if (this.parent && this.child) {
+            const strategy = getAttachmentStrategy(this.parent);
+            if (strategy) {
+                detachChild(this.child, strategy);
+            }
+        }
+        this.controller.dispose();
+        this.hasAppliedInitial = false;
+        this.child = null;
+        super.unmount();
+    }
+    onChildChange(oldChild) {
+        if (!this.parent)
+            return;
+        const strategy = getAttachmentStrategy(this.parent);
+        if (!strategy)
+            return;
+        if (oldChild && !this.child) {
+            detachChild(oldChild, strategy);
+        }
+        else if (oldChild && this.child && oldChild !== this.child) {
+            if (isRemovable(this.parent)) {
+                this.parent.remove(oldChild);
+            }
+            attachChild(this.child, strategy);
+        }
+        else if (!oldChild && this.child) {
+            attachChild(this.child, strategy);
+        }
+        if (!this.child)
+            return;
+        this.controller.setWidget(this.child);
+        if (!this.hasAppliedInitial && this.props.initial) {
+            this.controller.applyImmediate(this.props.initial);
+            this.hasAppliedInitial = true;
+        }
+        if (!this.hasStartedAnimation && this.props.animate) {
+            this.hasStartedAnimation = true;
+            this.startAnimation();
+        }
+    }
+    startAnimation() {
+        const from = this.props.initial ?? {};
+        const to = this.props.animate ?? {};
+        const transition = this.props.transition ?? {};
+        const onComplete = this.props.onAnimationComplete;
+        this.controller.animate(from, to, transition, onComplete);
+    }
+}
+function shallowObjectEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+}
+registerNodeClass(AnimationNode);

package/dist/nodes/animation/animation-style-sheet.d.ts

@@ -0,0 +1,16 @@
+export declare function getAnimationStyleSheet(): AnimationStyleSheet;
+declare class AnimationStyleSheet {
+    private provider;
+    private display;
+    private rules;
+    private dirty;
+    private flushScheduled;
+    setRule(widgetId: string, transformCss: string): void;
+    removeRule(widgetId: string): void;
+    private markDirty;
+    private scheduleFlush;
+    private flush;
+    private ensureProvider;
+    dispose(): void;
+}
+export {};

package/dist/nodes/animation/animation-style-sheet.js

@@ -0,0 +1,74 @@
+import { isStarted } from "@gtkx/ffi";
+import * as Gdk from "@gtkx/ffi/gdk";
+import * as Gtk from "@gtkx/ffi/gtk";
+const STYLE_PROVIDER_PRIORITY_ANIMATIONS = 700;
+let instance = null;
+export function getAnimationStyleSheet() {
+    if (!instance) {
+        instance = new AnimationStyleSheet();
+    }
+    return instance;
+}
+class AnimationStyleSheet {
+    provider = null;
+    display = null;
+    rules = new Map();
+    dirty = false;
+    flushScheduled = false;
+    setRule(widgetId, transformCss) {
+        const rule = `#${widgetId} { transform-origin: center center; transform: ${transformCss}; }`;
+        this.rules.set(widgetId, rule);
+        this.markDirty();
+    }
+    removeRule(widgetId) {
+        if (this.rules.delete(widgetId)) {
+            this.markDirty();
+        }
+    }
+    markDirty() {
+        this.dirty = true;
+        this.scheduleFlush();
+    }
+    scheduleFlush() {
+        if (this.flushScheduled)
+            return;
+        this.flushScheduled = true;
+        if (isStarted) {
+            queueMicrotask(() => this.flush());
+        }
+    }
+    flush() {
+        this.flushScheduled = false;
+        if (!this.dirty)
+            return;
+        this.dirty = false;
+        if (!isStarted)
+            return;
+        this.ensureProvider();
+        if (this.rules.size === 0) {
+            this.provider?.loadFromString("");
+            return;
+        }
+        const css = [...this.rules.values()].join("\n");
+        this.provider?.loadFromString(css);
+    }
+    ensureProvider() {
+        if (this.provider)
+            return;
+        this.provider = new Gtk.CssProvider();
+        this.display = Gdk.DisplayManager.get().getDefaultDisplay();
+        if (this.display) {
+            Gtk.StyleContext.addProviderForDisplay(this.display, this.provider, STYLE_PROVIDER_PRIORITY_ANIMATIONS);
+        }
+    }
+    dispose() {
+        if (this.provider && this.display) {
+            Gtk.StyleContext.removeProviderForDisplay(this.display, this.provider);
+        }
+        this.provider = null;
+        this.display = null;
+        this.rules.clear();
+        this.dirty = false;
+        this.flushScheduled = false;
+    }
+}

package/dist/nodes/animation/index.d.ts

@@ -0,0 +1,4 @@
+import "./animation-node.js";
+export type { AnimatableProperties } from "./animation-controller.js";
+export type { SpringTransition, TimedTransition, Transition } from "./animation-factory.js";
+export type { AnimationProps } from "./animation-node.js";

package/dist/nodes/animation/index.js

@@ -0,0 +1 @@
+import "./animation-node.js";

package/dist/nodes/animation/property-mapper.d.ts

@@ -0,0 +1,11 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { TransformProperty } from "./transform-state.js";
+export type AnimatableProperty = TransformProperty | "opacity";
+type PropertyAccessor = {
+    get: (widget: Gtk.Widget) => number;
+    set: (widget: Gtk.Widget, value: number) => void;
+};
+export declare function getPropertyAccessor(property: AnimatableProperty): PropertyAccessor;
+export declare function isAnimatableProperty(property: string): property is AnimatableProperty;
+export declare function isTransformProperty(property: string): property is TransformProperty;
+export {};

package/dist/nodes/animation/property-mapper.js

@@ -0,0 +1,36 @@
+import { getTransformState } from "./widget-registry.js";
+const TRANSFORM_DEFAULTS = {
+    x: 0,
+    y: 0,
+    scale: 1,
+    scaleX: 1,
+    scaleY: 1,
+    rotate: 0,
+};
+function createTransformAccessor(property) {
+    return {
+        get: (widget) => getTransformState(widget)?.get(property) ?? TRANSFORM_DEFAULTS[property],
+        set: (widget, value) => getTransformState(widget)?.set(property, value),
+    };
+}
+const propertyAccessors = {
+    opacity: {
+        get: (widget) => widget.getOpacity(),
+        set: (widget, value) => widget.setOpacity(value),
+    },
+    x: createTransformAccessor("x"),
+    y: createTransformAccessor("y"),
+    scale: createTransformAccessor("scale"),
+    scaleX: createTransformAccessor("scaleX"),
+    scaleY: createTransformAccessor("scaleY"),
+    rotate: createTransformAccessor("rotate"),
+};
+export function getPropertyAccessor(property) {
+    return propertyAccessors[property];
+}
+export function isAnimatableProperty(property) {
+    return property in propertyAccessors;
+}
+export function isTransformProperty(property) {
+    return property in TRANSFORM_DEFAULTS;
+}

package/dist/nodes/animation/transform-state.d.ts

@@ -0,0 +1,11 @@
+export type TransformProperty = "x" | "y" | "scale" | "scaleX" | "scaleY" | "rotate";
+export declare class TransformState {
+    private values;
+    private onChangeCallback;
+    constructor(onChange?: () => void);
+    get(property: TransformProperty): number;
+    set(property: TransformProperty, value: number): void;
+    isDefault(): boolean;
+    toCss(): string;
+    reset(): void;
+}

package/dist/nodes/animation/transform-state.js

@@ -0,0 +1,57 @@
+const DEFAULT_VALUES = {
+    x: 0,
+    y: 0,
+    scale: 1,
+    scaleX: 1,
+    scaleY: 1,
+    rotate: 0,
+};
+export class TransformState {
+    values = { ...DEFAULT_VALUES };
+    onChangeCallback = null;
+    constructor(onChange) {
+        this.onChangeCallback = onChange ?? null;
+    }
+    get(property) {
+        return this.values[property];
+    }
+    set(property, value) {
+        if (this.values[property] !== value) {
+            this.values[property] = value;
+            this.onChangeCallback?.();
+        }
+    }
+    isDefault() {
+        return (this.values.x === 0 &&
+            this.values.y === 0 &&
+            this.values.scale === 1 &&
+            this.values.scaleX === 1 &&
+            this.values.scaleY === 1 &&
+            this.values.rotate === 0);
+    }
+    toCss() {
+        const transforms = [];
+        if (this.values.x !== 0 || this.values.y !== 0) {
+            transforms.push(`translate(${this.values.x}px, ${this.values.y}px)`);
+        }
+        const hasUniformScale = this.values.scale !== 1;
+        const hasAxisScale = this.values.scaleX !== 1 || this.values.scaleY !== 1;
+        if (hasUniformScale) {
+            transforms.push(`scale(${this.values.scale})`);
+        }
+        else if (hasAxisScale) {
+            transforms.push(`scale(${this.values.scaleX}, ${this.values.scaleY})`);
+        }
+        if (this.values.rotate !== 0) {
+            transforms.push(`rotate(${this.values.rotate}deg)`);
+        }
+        return transforms.length > 0 ? transforms.join(" ") : "none";
+    }
+    reset() {
+        const wasDefault = this.isDefault();
+        this.values = { ...DEFAULT_VALUES };
+        if (!wasDefault) {
+            this.onChangeCallback?.();
+        }
+    }
+}

package/dist/nodes/animation/widget-registry.d.ts

@@ -0,0 +1,5 @@
+import type * as Gtk from "@gtkx/ffi/gtk";
+import { TransformState } from "./transform-state.js";
+export declare function registerWidget(widget: Gtk.Widget): TransformState;
+export declare function unregisterWidget(widget: Gtk.Widget): void;
+export declare function getTransformState(widget: Gtk.Widget): TransformState | null;

package/dist/nodes/animation/widget-registry.js

@@ -0,0 +1,42 @@
+import { getNativeId } from "@gtkx/ffi";
+import { getAnimationStyleSheet } from "./animation-style-sheet.js";
+import { TransformState } from "./transform-state.js";
+const widgets = new WeakMap();
+const styleSheet = getAnimationStyleSheet();
+export function registerWidget(widget) {
+    const existing = widgets.get(widget);
+    if (existing) {
+        return existing.transformState;
+    }
+    const nativeId = getNativeId(widget.handle);
+    const cssId = `gtkx-anim-${nativeId}`;
+    const originalName = widget.getName();
+    widget.setName(cssId);
+    const transformState = new TransformState(() => {
+        if (transformState.isDefault()) {
+            styleSheet.removeRule(cssId);
+        }
+        else {
+            styleSheet.setRule(cssId, transformState.toCss());
+        }
+    });
+    widgets.set(widget, {
+        cssId,
+        originalName,
+        transformState,
+    });
+    return transformState;
+}
+export function unregisterWidget(widget) {
+    const entry = widgets.get(widget);
+    if (!entry)
+        return;
+    styleSheet.removeRule(entry.cssId);
+    if (entry.originalName !== null) {
+        widget.setName(entry.originalName);
+    }
+    widgets.delete(widget);
+}
+export function getTransformState(widget) {
+    return widgets.get(widget)?.transformState ?? null;
+}

package/dist/nodes/application.js

@@ -2,20 +2,21 @@ import * as Gtk from "@gtkx/ffi/gtk";
 import { Node } from "../node.js";
 import { registerNodeClass } from "../registry.js";
 import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { isContainerType } from "./internal/utils.js";
+import { DialogNode } from "./dialog.js";
+import { matchesAnyClass } from "./internal/utils.js";
 import { MenuNode } from "./menu.js";
-import { Menu } from "./models/menu.js";
+import { MenuModel } from "./models/menu.js";
 import { WindowNode } from "./window.js";
 class ApplicationNode extends Node {
     static priority = 0;
     menu;
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Application, containerOrClass);
+        return matchesAnyClass([Gtk.Application], containerOrClass);
     }
     constructor(typeName, props, container, rootContainer) {
         super(typeName, props, container, rootContainer);
         const application = rootContainer instanceof Gtk.Application ? rootContainer : undefined;
-        this.menu = new Menu("root", {}, container, application);
+        this.menu = new MenuModel("root", {}, rootContainer, container, application);
     }
     appendChild(child) {
         if (child instanceof MenuNode) {
@@ -26,7 +27,10 @@ class ApplicationNode extends Node {
         if (child instanceof WindowNode && child.container instanceof Gtk.ApplicationWindow) {
             return;
         }
-        throw new Error(`Cannot append '${child.typeName}' to 'Application': expected ApplicationWindow or MenuItem`);
+        if (child instanceof DialogNode) {
+            return;
+        }
+        throw new Error(`Cannot append '${child.typeName}' to 'Application': expected ApplicationWindow, Dialog, or MenuItem`);
     }
     insertBefore(child, before) {
         if (child instanceof MenuNode) {
@@ -36,7 +40,10 @@ class ApplicationNode extends Node {
         if (child instanceof WindowNode && child.container instanceof Gtk.ApplicationWindow) {
             return;
         }
-        throw new Error(`Cannot insert '${child.typeName}' into 'Application': expected ApplicationWindow or MenuItem`);
+        if (child instanceof DialogNode) {
+            return;
+        }
+        throw new Error(`Cannot insert '${child.typeName}' into 'Application': expected ApplicationWindow, Dialog, or MenuItem`);
     }
     removeChild(child) {
         if (child instanceof MenuNode) {
@@ -51,7 +58,10 @@ class ApplicationNode extends Node {
         if (child instanceof WindowNode && child.container instanceof Gtk.ApplicationWindow) {
             return;
         }
-        throw new Error(`Cannot remove '${child.typeName}' from 'Application': expected ApplicationWindow or MenuItem`);
+        if (child instanceof DialogNode) {
+            return;
+        }
+        throw new Error(`Cannot remove '${child.typeName}' from 'Application': expected ApplicationWindow, Dialog, or MenuItem`);
     }
 }
 registerNodeClass(ApplicationNode);

package/dist/nodes/autowrapped.js

@@ -1,4 +1,4 @@
-import { batch, isObjectEqual } from "@gtkx/ffi";
+import { isObjectEqual } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { AUTOWRAP_CLASSES } from "../generated/internal.js";
 import { registerNodeClass } from "../registry.js";
@@ -10,7 +10,7 @@ const isAutowrappedChild = (obj) => {
     return obj instanceof Gtk.ListBoxRow || obj instanceof Gtk.FlowBoxChild;
 };
 class AutowrappedNode extends WidgetNode {
-    static priority = 2;
+    static priority = 1;
     static matches(_type, containerOrClass) {
         return matchesAnyClass(AUTOWRAP_CLASSES, containerOrClass);
     }
@@ -22,18 +22,16 @@ class AutowrappedNode extends WidgetNode {
         if (!(child instanceof WidgetNode)) {
             throw new Error(`Cannot append '${child.typeName}' to 'ListBox/FlowBox': expected Widget`);
         }
-        batch(() => {
-            if (isAutowrappedChild(child.container)) {
-                const currentParent = child.container.getParent();
-                if (currentParent !== null && isRemovable(currentParent)) {
-                    currentParent.remove(child.container);
-                }
-            }
-            else {
-                this.removeExistingWrapper(child.container);
+        if (isAutowrappedChild(child.container)) {
+            const currentParent = child.container.getParent();
+            if (currentParent !== null && isRemovable(currentParent)) {
+                currentParent.remove(child.container);
             }
-            this.container.append(child.container);
-        });
+        }
+        else {
+            this.removeExistingWrapper(child.container);
+        }
+        this.container.append(child.container);
     }
     removeChild(child) {
         if (child instanceof SlotNode) {
@@ -43,17 +41,15 @@ class AutowrappedNode extends WidgetNode {
         if (!(child instanceof WidgetNode)) {
             throw new Error(`Cannot remove '${child.typeName}' from 'ListBox/FlowBox': expected Widget`);
         }
-        batch(() => {
-            if (!isAutowrappedChild(child.container)) {
-                const wrapper = child.container.getParent();
-                if (wrapper && isSingleChild(wrapper)) {
-                    wrapper.setChild(null);
-                    this.container.remove(wrapper);
-                    return;
-                }
+        if (!isAutowrappedChild(child.container)) {
+            const wrapper = child.container.getParent();
+            if (wrapper && isSingleChild(wrapper)) {
+                wrapper.setChild(null);
+                this.container.remove(wrapper);
+                return;
             }
-            this.container.remove(child.container);
-        });
+        }
+        this.container.remove(child.container);
     }
     insertBefore(child, before) {
         if (child instanceof SlotNode) {
@@ -61,31 +57,29 @@ class AutowrappedNode extends WidgetNode {
             return;
         }
         if (!(child instanceof WidgetNode) || !(before instanceof WidgetNode)) {
-            throw new Error(`Cannot insert '${child.typeName}' before '${before.typeName}' in 'ListBox/FlowBox': expected Widget`);
+            throw new Error(`Cannot insert '${child.typeName}' into 'ListBox/FlowBox': expected Widget`);
         }
-        batch(() => {
-            const currentParent = child.container.getParent();
-            if (currentParent !== null) {
-                if (isAutowrappedChild(child.container)) {
-                    if (isRemovable(currentParent)) {
-                        currentParent.remove(child.container);
-                    }
-                }
-                else {
-                    this.removeExistingWrapper(child.container);
+        const currentParent = child.container.getParent();
+        if (currentParent !== null) {
+            if (isAutowrappedChild(child.container)) {
+                if (isRemovable(currentParent)) {
+                    currentParent.remove(child.container);
                 }
             }
-            else if (!isAutowrappedChild(child.container)) {
-                this.removeExistingWrapper(child.container);
-            }
-            const position = this.findChildPosition(before);
-            if (position !== null) {
-                this.container.insert(child.container, position);
-            }
             else {
-                this.container.append(child.container);
+                this.removeExistingWrapper(child.container);
             }
-        });
+        }
+        else if (!isAutowrappedChild(child.container)) {
+            this.removeExistingWrapper(child.container);
+        }
+        const position = this.findChildPosition(before);
+        if (position !== null) {
+            this.container.insert(child.container, position);
+        }
+        else {
+            this.container.append(child.container);
+        }
     }
     removeExistingWrapper(childWidget) {
         const existingWrapper = childWidget.getParent();

package/dist/nodes/calendar.js

@@ -1,70 +1,31 @@
 import * as Gtk from "@gtkx/ffi/gtk";
 import { registerNodeClass } from "../registry.js";
-import { CommitPriority, scheduleAfterCommit } from "../scheduler.js";
-import { CalendarMarkNode } from "./calendar-mark.js";
-import { isContainerType } from "./internal/utils.js";
-import { SlotNode } from "./slot.js";
+import { filterProps, matchesAnyClass, primitiveArrayEqual } from "./internal/utils.js";
 import { WidgetNode } from "./widget.js";
+const OWN_PROPS = ["markedDays"];
 class CalendarNode extends WidgetNode {
     static priority = 1;
-    markChildren = [];
+    appliedMarks = [];
     static matches(_type, containerOrClass) {
-        return isContainerType(Gtk.Calendar, containerOrClass);
+        return matchesAnyClass([Gtk.Calendar], containerOrClass);
     }
-    appendChild(child) {
-        if (child instanceof CalendarMarkNode) {
-            child.setCalendar(this.container, () => this.scheduleRebuildAllMarks());
-            this.markChildren.push(child);
-            scheduleAfterCommit(() => child.addMark());
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.appendChild(child);
-            return;
-        }
-        throw new Error(`Cannot append '${child.typeName}' to 'Calendar': expected x.CalendarMark or Widget`);
+    updateProps(oldProps, newProps) {
+        super.updateProps(oldProps ? filterProps(oldProps, OWN_PROPS) : null, filterProps(newProps, OWN_PROPS));
+        this.applyOwnProps(oldProps, newProps);
     }
-    insertBefore(child, before) {
-        if (child instanceof CalendarMarkNode) {
-            child.setCalendar(this.container, () => this.scheduleRebuildAllMarks());
-            const beforeIndex = this.markChildren.indexOf(before);
-            if (beforeIndex >= 0) {
-                this.markChildren.splice(beforeIndex, 0, child);
-            }
-            else {
-                this.markChildren.push(child);
-            }
-            this.scheduleRebuildAllMarks();
-            return;
-        }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.insertBefore(child, before);
-            return;
-        }
-        throw new Error(`Cannot insert '${child.typeName}' into 'Calendar': expected x.CalendarMark or Widget`);
+    applyOwnProps(_oldProps, newProps) {
+        this.applyMarkedDays(newProps);
     }
-    removeChild(child) {
-        if (child instanceof CalendarMarkNode) {
-            const index = this.markChildren.indexOf(child);
-            if (index >= 0) {
-                this.markChildren.splice(index, 1);
-            }
-            this.scheduleRebuildAllMarks(CommitPriority.HIGH);
+    applyMarkedDays(newProps) {
+        const newMarkedDays = newProps.markedDays ?? [];
+        if (primitiveArrayEqual(this.appliedMarks, newMarkedDays)) {
             return;
         }
-        if (child instanceof SlotNode || child instanceof WidgetNode) {
-            super.removeChild(child);
-            return;
+        this.container.clearMarks();
+        for (const day of newMarkedDays) {
+            this.container.markDay(day);
         }
-        throw new Error(`Cannot remove '${child.typeName}' from 'Calendar': expected x.CalendarMark or Widget`);
-    }
-    scheduleRebuildAllMarks(priority = CommitPriority.NORMAL) {
-        scheduleAfterCommit(() => {
-            this.container.clearMarks();
-            for (const mark of this.markChildren) {
-                mark.addMark();
-            }
-        }, priority);
+        this.appliedMarks = [...newMarkedDays];
     }
 }
 registerNodeClass(CalendarNode);

package/dist/nodes/color-dialog-button.d.ts

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