@nanahoshi/mona-ui 0.1.0

package/types/nanahoshi-mona-ui-tree-view.d.ts

@@ -0,0 +1,274 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit } from '@angular/core';
+import { FilterChangeEvent, FilterableOptions } from '@nanahoshi/mona-ui/common';
+import { ITreeView, TreeService, ChildrenSelector, DataStructure, NodeClickEvent, NodeItem, DropPosition, NodeMoveSnapshot, NodeKeySelector, NodeCheckEvent, CheckableOptions, DisableOptions, NodeDragEvent, NodeDragEndEvent, NodeDragStartEvent, NodeDropEvent, DraggableOptions, ExpandableOptions, NodeSelectEvent, SelectableOptions } from '@nanahoshi/mona-ui/internal/tree';
+export { CheckableOptions, ChildrenSelector, DataStructure, DisableOptions, DraggableOptions, DropPositionChangeEvent, ExpandableOptions, NodeCheckEvent, NodeClickEvent, NodeDragEndEvent, NodeDragEvent, NodeDragStartEvent, NodeDropEvent, NodeItem, NodeKeySelector, NodeMoveSnapshot, SelectableOptions, moveFlatTreeNode, moveTreeNode } from '@nanahoshi/mona-ui/internal/tree';
+import { Predicate, Selector } from '@mirei/ts-collections';
+
+interface TreeViewNodeTemplateContext<T> {
+    $implicit: T;
+    element: HTMLElement;
+}
+
+declare class TreeViewComponent<T> implements ITreeView<T> {
+    #private;
+    protected readonly nodeTemplate: _angular_core.Signal<TemplateRef<TreeViewNodeTemplateContext<T>> | undefined>;
+    protected readonly treeService: TreeService<T>;
+    protected readonly filterAriaLabel: _angular_core.Signal<string>;
+    /**
+     * @description Enables CSS transitions when nodes expand or collapse.
+     * @default true
+     */
+    readonly animate: _angular_core.InputSignal<boolean>;
+    /**
+     * @description Accessible name for the tree. Describe what the tree represents. When empty, assistive technology announces the role without a label.
+     * @default ""
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * @description Property name or accessor used to derive a node's children from a data item. Accepts a property name, a function returning the children, or a function returning an observable of the children.
+     * @default ""
+     */
+    readonly children: _angular_core.InputSignal<ChildrenSelector<T>>;
+    /**
+     * @description Collection of items to render.
+     * @default []
+     */
+    readonly data: _angular_core.InputSignal<Iterable<T>>;
+    /**
+     * @description Predicate that determines whether a node has children. Required when the children selector returns an observable.
+     * @default null
+     */
+    readonly hasChildren: _angular_core.InputSignal<Predicate<T> | null>;
+    /**
+     * @description Property name that holds a node's unique identifier. Required when `mode` is set to `"flat"`.
+     * @default ""
+     */
+    readonly idField: _angular_core.InputSignal<string>;
+    /**
+     * @description Shape of the source data: `"hierarchical"` for nested items via `children`, or `"flat"` for a flat list linked by `idField` and `parentIdField`.
+     * @default "hierarchical"
+     */
+    readonly mode: _angular_core.InputSignal<DataStructure>;
+    /**
+     * @description Emitted when the tree-view loses focus.
+     */
+    readonly blur: _angular_core.OutputEmitterRef<FocusEvent>;
+    /**
+     * @description Emitted when the tree-view gains focus.
+     */
+    readonly focus: _angular_core.OutputEmitterRef<FocusEvent>;
+    /**
+     * @description Emitted when a node is clicked.
+     */
+    readonly nodeClick: _angular_core.OutputEmitterRef<NodeClickEvent<T>>;
+    /**
+     * @description Property name that holds a node's parent identifier. Required when `mode` is set to `"flat"`.
+     * @default ""
+     */
+    readonly parentIdField: _angular_core.InputSignal<string>;
+    /**
+     * @description Property name or accessor used to derive the display text from a data item.
+     * @default ""
+     */
+    readonly textField: _angular_core.InputSignal<string | Selector<T, string>>;
+    constructor();
+    moveNode(source: NodeItem<T>, target: NodeItem<T>, position: DropPosition): NodeMoveSnapshot | null;
+    undoMoveNode(snapshot: NodeMoveSnapshot): void;
+    protected onFilterChange(event: FilterChangeEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeViewComponent<any>, "mona-tree-view", never, { "animate": { "alias": "animate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "children": { "alias": "children"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "hasChildren": { "alias": "hasChildren"; "required": false; "isSignal": true; }; "idField": { "alias": "idField"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "parentIdField": { "alias": "parentIdField"; "required": false; "isSignal": true; }; "textField": { "alias": "textField"; "required": false; "isSignal": true; }; }, { "blur": "blur"; "focus": "focus"; "nodeClick": "nodeClick"; }, ["nodeTemplate"], never, true, never>;
+}
+
+declare class TreeViewCheckableDirective<T, K = T> implements OnInit {
+    #private;
+    /**
+     * @description Property name or accessor used to derive a node's check key from its data. Falls back to the node's data when unset.
+     * @default ""
+     */
+    readonly checkBy: _angular_core.InputSignal<NodeKeySelector<T, K> | undefined>;
+    /**
+     * @description Keys of the currently checked nodes.
+     * @default []
+     */
+    readonly checkedKeys: _angular_core.InputSignal<Iterable<K>>;
+    /**
+     * @description Emitted when the checked keys change.
+     */
+    readonly checkedKeysChange: _angular_core.OutputEmitterRef<K[]>;
+    /**
+     * @description Predicate that determines whether a node displays a checkbox. When unset, every node displays a checkbox.
+     * @default null
+     */
+    readonly hasCheckbox: _angular_core.InputSignal<((data: T, uid: string) => boolean) | null>;
+    /**
+     * @description Emitted when a node is checked or unchecked.
+     */
+    readonly nodeCheck: _angular_core.OutputEmitterRef<NodeCheckEvent<T>>;
+    /**
+     * @description Configures check mode and whether checking a node also checks its children or parents. Merged over `{ checkChildren: true, checkParents: true, enabled: true, mode: "multiple" }` when applied bare.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | Partial<CheckableOptions>>;
+    constructor();
+    ngOnInit(): void;
+    private setNodeCheckSubscription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewCheckableDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeViewCheckableDirective<any, any>, "mona-tree-view[monaTreeViewCheckable]", ["monaTreeViewCheckable"], { "checkBy": { "alias": "checkBy"; "required": false; "isSignal": true; }; "checkedKeys": { "alias": "checkedKeys"; "required": false; "isSignal": true; }; "hasCheckbox": { "alias": "hasCheckbox"; "required": false; "isSignal": true; }; "options": { "alias": "monaTreeViewCheckable"; "required": false; "isSignal": true; }; }, { "checkedKeysChange": "checkedKeysChange"; "nodeCheck": "nodeCheck"; }, never, never, true, never>;
+}
+
+declare class TreeViewDisableDirective<T, K = T> {
+    #private;
+    /**
+     * @description Property name or accessor used to derive a node's disable key from its data. Falls back to the node's data when unset.
+     * @default ""
+     */
+    readonly disableBy: _angular_core.InputSignal<NodeKeySelector<T, K> | undefined>;
+    /**
+     * @description Keys of the currently disabled nodes.
+     * @default []
+     */
+    readonly disabledKeys: _angular_core.InputSignal<Iterable<K>>;
+    /**
+     * @description Configures whether disabling a node also disables its children. Merged over `{ disableChildren: true, enabled: true }` when applied bare.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | Partial<DisableOptions>>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewDisableDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeViewDisableDirective<any, any>, "mona-tree-view[monaTreeViewDisable]", ["monaTreeViewDisable"], { "disableBy": { "alias": "disableBy"; "required": false; "isSignal": true; }; "disabledKeys": { "alias": "disabledKeys"; "required": false; "isSignal": true; }; "options": { "alias": "monaTreeViewDisable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TreeViewDragAndDropDirective<T> {
+    #private;
+    /**
+     * @description Emitted while a node is being dragged.
+     */
+    readonly nodeDrag: _angular_core.OutputEmitterRef<NodeDragEvent<T>>;
+    /**
+     * @description Emitted when a node drag ends.
+     */
+    readonly nodeDragEnd: _angular_core.OutputEmitterRef<NodeDragEndEvent<T>>;
+    /**
+     * @description Emitted when a node drag starts.
+     */
+    readonly nodeDragStart: _angular_core.OutputEmitterRef<NodeDragStartEvent<T>>;
+    /**
+     * @description Emitted when a node is dropped.
+     */
+    readonly nodeDrop: _angular_core.OutputEmitterRef<NodeDropEvent<T>>;
+    /**
+     * @description Configures whether dragging nodes to reorder or reparent them is enabled. Merged over `{ enabled: true }` when applied bare.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | Partial<DraggableOptions>>;
+    constructor();
+    setSubscriptions(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewDragAndDropDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeViewDragAndDropDirective<any>, "mona-tree-view[monaTreeViewDragAndDrop]", ["monaTreeViewDragAndDrop"], { "options": { "alias": "monaTreeViewDragAndDrop"; "required": false; "isSignal": true; }; }, { "nodeDrag": "nodeDrag"; "nodeDragEnd": "nodeDragEnd"; "nodeDragStart": "nodeDragStart"; "nodeDrop": "nodeDrop"; }, never, never, true, never>;
+}
+
+declare class TreeViewExpandableDirective<T, K = T> {
+    #private;
+    /**
+     * @description Emitted when a node is collapsed.
+     */
+    readonly collapse: _angular_core.OutputEmitterRef<NodeItem<T>>;
+    /**
+     * @description Emitted when a node is expanded.
+     */
+    readonly expand: _angular_core.OutputEmitterRef<NodeItem<T>>;
+    /**
+     * @description Property name or accessor used to derive a node's expand key from its data. Falls back to the node's data when unset.
+     * @default ""
+     */
+    readonly expandBy: _angular_core.InputSignal<NodeKeySelector<T, K> | undefined>;
+    /**
+     * @description Keys of the currently expanded nodes.
+     * @default []
+     */
+    readonly expandedKeys: _angular_core.InputSignal<Iterable<K>>;
+    /**
+     * @description Emitted when the expanded keys change.
+     */
+    readonly expandedKeysChange: _angular_core.OutputEmitterRef<K[]>;
+    /**
+     * @description Configures whether expanding and collapsing nodes is enabled. Merged over `{ enabled: true }` when applied bare.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | Partial<ExpandableOptions>>;
+    constructor();
+    setSubscriptions(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewExpandableDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeViewExpandableDirective<any, any>, "mona-tree-view[monaTreeViewExpandable]", ["monaTreeViewExpandable"], { "expandBy": { "alias": "expandBy"; "required": false; "isSignal": true; }; "expandedKeys": { "alias": "expandedKeys"; "required": false; "isSignal": true; }; "options": { "alias": "monaTreeViewExpandable"; "required": false; "isSignal": true; }; }, { "collapse": "collapse"; "expand": "expand"; "expandedKeysChange": "expandedKeysChange"; }, never, never, true, never>;
+}
+
+declare class TreeViewFilterableDirective<T> {
+    #private;
+    /**
+     * @description Current filter text used to narrow the visible nodes.
+     * @default ""
+     */
+    readonly filter: _angular_core.InputSignal<string>;
+    /**
+     * @description Emitted when the filter value changes.
+     */
+    readonly filterChange: _angular_core.OutputEmitterRef<FilterChangeEvent>;
+    /**
+     * @description Placeholder text shown in the filter input.
+     * @default ""
+     */
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    /**
+     * @description Configures the filter operator, case sensitivity, and debounce delay. Merged over `{ enabled: true, operator: "contains", caseSensitive: false, debounce: 0 }` when applied bare.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | Partial<FilterableOptions>>;
+    constructor();
+    private setSubscription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewFilterableDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeViewFilterableDirective<any>, "mona-tree-view[monaTreeViewFilterable]", ["monaTreeViewFilterable"], { "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "options": { "alias": "monaTreeViewFilterable"; "required": false; "isSignal": true; }; }, { "filterChange": "filterChange"; }, never, never, true, never>;
+}
+
+declare class TreeViewNodeTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewNodeTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeViewNodeTemplateDirective, "ng-template[monaTreeViewNodeTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TreeViewSelectableDirective<T, K = T> implements OnInit {
+    #private;
+    /**
+     * @description Emitted when a node is selected or deselected.
+     */
+    readonly nodeSelect: _angular_core.OutputEmitterRef<NodeSelectEvent<T>>;
+    /**
+     * @description Property name or accessor used to derive a node's selection key from its data. Falls back to the node's data when unset.
+     * @default ""
+     */
+    readonly selectBy: _angular_core.InputSignal<NodeKeySelector<T, K> | undefined>;
+    /**
+     * @description Keys of the currently selected nodes.
+     * @default []
+     */
+    readonly selectedKeys: _angular_core.InputSignal<Iterable<K>>;
+    /**
+     * @description Emitted when the selected keys change.
+     */
+    readonly selectedKeysChange: _angular_core.OutputEmitterRef<K[]>;
+    /**
+     * @description Emitted when the selection changes.
+     */
+    readonly selectionChange: _angular_core.OutputEmitterRef<NodeItem<T>>;
+    /**
+     * @description Configures selection mode, toggleability, and whether only child nodes are selectable. Merged over `{ childrenOnly: false, enabled: true, mode: "single", toggleable: false }` when applied bare.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | Partial<SelectableOptions>>;
+    constructor();
+    ngOnInit(): void;
+    private setNodeSelectSubscription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewSelectableDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeViewSelectableDirective<any, any>, "mona-tree-view[monaTreeViewSelectable]", ["monaTreeViewSelectable"], { "selectBy": { "alias": "selectBy"; "required": false; "isSignal": true; }; "selectedKeys": { "alias": "selectedKeys"; "required": false; "isSignal": true; }; "options": { "alias": "monaTreeViewSelectable"; "required": false; "isSignal": true; }; }, { "nodeSelect": "nodeSelect"; "selectedKeysChange": "selectedKeysChange"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+export { TreeViewCheckableDirective, TreeViewComponent, TreeViewDisableDirective, TreeViewDragAndDropDirective, TreeViewExpandableDirective, TreeViewFilterableDirective, TreeViewNodeTemplateDirective, TreeViewSelectableDirective };

package/types/nanahoshi-mona-ui-window.d.ts

@@ -0,0 +1,295 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, ComponentRef, TemplateRef, Type } from '@angular/core';
+import { PopupCloseEvent, PopupRef } from '@nanahoshi/mona-ui/popup';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantInputs, Action } from '@nanahoshi/mona-ui/internal';
+import { ThemeStyle } from '@nanahoshi/mona-ui/theme';
+import { VariantProps } from 'class-variance-authority';
+import { Observable } from 'rxjs';
+
+declare const windowBaseThemeVariants: (theme: ThemeStyle) => (props?: ({
+    rounded?: "none" | "small" | "medium" | "large" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const windowContentContainerThemeVariants: (theme: ThemeStyle) => (props?: ({
+    rounded?: "none" | "small" | "medium" | "large" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const windowContentThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const windowResizerThemeVariants: (theme: ThemeStyle) => (props?: ({
+    position?: "north" | "south" | "east" | "west" | "northeast" | "northwest" | "southeast" | "southwest" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const windowTitleBarActionThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const windowTitleBarThemeVariants: (theme: ThemeStyle) => (props?: ({
+    look?: "default" | "primary" | null | undefined;
+    rounded?: "none" | "small" | "medium" | "large" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const windowTitleContainerThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const windowTitleThemeVariants: (theme: ThemeStyle) => (props?: ({
+    look?: "default" | "primary" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type WindowBaseVariantProps = VariantProps<ReturnType<typeof windowBaseThemeVariants>>;
+type WindowBaseVariantInput = VariantInputs<WindowBaseVariantProps>;
+type WindowContentContainerVariantProps = VariantProps<ReturnType<typeof windowContentContainerThemeVariants>>;
+type WindowContentContainerVariantInput = VariantInputs<WindowContentContainerVariantProps>;
+type WindowContentVariantProps = VariantProps<ReturnType<typeof windowContentThemeVariants>>;
+type WindowResizerVariantProps = VariantProps<ReturnType<typeof windowResizerThemeVariants>>;
+type WindowResizerVariantInput = VariantInputs<WindowResizerVariantProps>;
+type WindowTitleBarActionVariantProps = VariantProps<ReturnType<typeof windowTitleBarActionThemeVariants>>;
+type WindowTitleBarActionVariantInput = VariantInputs<WindowTitleBarActionVariantProps>;
+type WindowTitleBarVariantProps = VariantProps<ReturnType<typeof windowTitleBarThemeVariants>>;
+type WindowTitleBarVariantInput = VariantInputs<WindowTitleBarVariantProps>;
+type WindowTitleContainerVariantProps = VariantProps<ReturnType<typeof windowTitleContainerThemeVariants>>;
+type WindowTitleContainerVariantInput = VariantInputs<WindowTitleContainerVariantProps>;
+type WindowTitleVariantProps = VariantProps<ReturnType<typeof windowTitleThemeVariants>>;
+type WindowTitleVariantInput = VariantInputs<WindowTitleVariantProps>;
+type WindowVariantProps = WindowBaseVariantProps & WindowContentContainerVariantProps & WindowContentVariantProps & WindowResizerVariantProps & WindowTitleBarActionVariantProps & WindowTitleBarVariantProps & WindowTitleContainerVariantProps & WindowTitleVariantProps;
+type WindowVariantInput = WindowBaseVariantInput & WindowContentContainerVariantInput & Omit<WindowResizerVariantInput, "position"> & WindowTitleBarVariantInput & WindowTitleContainerVariantInput & WindowTitleBarActionVariantInput & WindowTitleVariantInput;
+
+declare class WindowComponent implements WindowVariantInput {
+    #private;
+    private readonly actionTemplate;
+    private readonly contentTemplate;
+    private readonly footerTemplate;
+    private readonly titleTemplate;
+    /**
+     * @description Sets the visibility of the close button in the window header.
+     * @default true
+     */
+    readonly closable: _angular_core.InputSignal<boolean>;
+    /**
+     * @description Emits when the window is about to be closed.
+     */
+    readonly close: _angular_core.OutputEmitterRef<PopupCloseEvent<unknown>>;
+    /**
+     * @description Emitted after the window has fully closed (post-animation). Preventing this event has no effect.
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * @description Sets whether the window should close when the escape key is pressed.
+     * @default true
+     */
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    /**
+     * @description Emits when the window dragging ends.
+     */
+    readonly dragEnd: _angular_core.OutputEmitterRef<void>;
+    /**
+     * @description Emits when the window dragging starts.
+     */
+    readonly dragStart: _angular_core.OutputEmitterRef<void>;
+    /**
+     * @description Sets whether the window can be dragged by the user.
+     * @default true
+     */
+    readonly draggable: _angular_core.InputSignal<boolean>;
+    /**
+     * @description Sets the element that should receive focus when the window is opened.
+     * Accepts an element reference or a query selector string.
+     */
+    readonly focusedElement: _angular_core.InputSignal<string | HTMLElement | ElementRef<HTMLElement> | null | undefined>;
+    /**
+     * @description Sets the height of the window.
+     */
+    readonly height: _angular_core.ModelSignal<number | undefined>;
+    /**
+     * @description Sets the left position of the window.
+     */
+    readonly left: _angular_core.ModelSignal<number | undefined>;
+    /**
+     * @description Sets the look of the window.
+     * @default "default"
+     */
+    readonly look: _angular_core.InputSignal<"default" | "primary" | null | undefined>;
+    /**
+     * @description Sets the maximum height of the window.
+     */
+    readonly maxHeight: _angular_core.InputSignal<number | undefined>;
+    /**
+     * @description Sets the maximum width of the window.
+     */
+    readonly maxWidth: _angular_core.InputSignal<number | undefined>;
+    /**
+     * @description Sets whether the user can maximize the window.
+     * @default true
+     */
+    readonly maximizable: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * @description Sets the minimum height of the window.
+     */
+    readonly minHeight: _angular_core.InputSignal<number | undefined>;
+    /**
+     * @description Sets the minimum width of the window.
+     */
+    readonly minWidth: _angular_core.InputSignal<number | undefined>;
+    /**
+     * @description Sets whether the user can minimize the window.
+     * @default true
+     */
+    readonly minimizable: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * @description Sets whether the window should have an overlay behind it.
+     * @default false
+     */
+    readonly modal: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * @description Sets whether the user can resize the window.
+     * @default false
+     */
+    readonly resizable: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * @description Sets the border radius of the window.
+     * @default "medium"
+     */
+    readonly rounded: _angular_core.InputSignal<"none" | "small" | "medium" | "large" | null | undefined>;
+    /**
+     * @description Sets the title of the window.
+     */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /**
+     * @description Sets the top position of the window.
+     */
+    readonly top: _angular_core.ModelSignal<number | undefined>;
+    /**
+     * @description Sets the width of the window.
+     */
+    readonly width: _angular_core.ModelSignal<number | undefined>;
+    constructor();
+    closeWindow(): void;
+    move(position: {
+        top?: number;
+        left?: number;
+    }): void;
+    openWindow(): void;
+    resize(dimensions: {
+        width?: number;
+        height?: number;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindowComponent, "mona-window", never, { "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "focusedElement": { "alias": "focusedElement"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "left": { "alias": "left"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "maximizable": { "alias": "maximizable"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "minimizable": { "alias": "minimizable"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "top": { "alias": "top"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "close": "close"; "closed": "closed"; "dragEnd": "dragEnd"; "dragStart": "dragStart"; "height": "heightChange"; "left": "leftChange"; "top": "topChange"; "width": "widthChange"; }, ["actionTemplate", "contentTemplate", "footerTemplate", "titleTemplate"], never, true, never>;
+}
+
+declare class WindowActionTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowActionTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WindowActionTemplateDirective, "ng-template[monaWindowActionTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WindowContentTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowContentTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WindowContentTemplateDirective, "ng-template[monaWindowContentTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WindowFooterTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowFooterTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WindowFooterTemplateDirective, "ng-template[monaWindowFooterTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class WindowTitleTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowTitleTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WindowTitleTemplateDirective, "ng-template[monaWindowTitleTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+interface MoveEvent {
+    left: number;
+    top: number;
+}
+
+interface ResizeEvent {
+    left: number;
+    height: number;
+    top: number;
+    width: number;
+}
+
+interface WindowRefParams<R = unknown> {
+    close: (result?: R) => void;
+    center: () => void;
+    closeWithDelay: (delay: number, result?: R) => void;
+    move: (params: {
+        top?: number;
+        left?: number;
+    }) => void;
+    resize: (params: {
+        width?: number;
+        height?: number;
+        center?: boolean;
+    }) => void;
+    get close$(): Observable<PopupCloseEvent<R>>;
+    get closed$(): Observable<void>;
+    get component(): ComponentRef<unknown> | null;
+    get drag$(): Observable<MoveEvent>;
+    get dragEnd$(): Observable<void>;
+    get dragStart$(): Observable<void>;
+    get element(): HTMLElement;
+    get height(): number;
+    get popupRef(): PopupRef;
+    get resize$(): Observable<ResizeEvent>;
+    get width(): number;
+}
+
+declare class WindowRef<R = unknown> implements WindowRefParams<R> {
+    #private;
+    constructor(options: WindowRefParams<R>);
+    center(): void;
+    close(result?: R): void;
+    closeWithDelay(delay: number, result?: R): void;
+    move(params: {
+        top?: number;
+        left?: number;
+    }): void;
+    resize(params: {
+        width?: number;
+        height?: number;
+        center?: boolean;
+    }): void;
+    get close$(): Observable<PopupCloseEvent<R>>;
+    get closed$(): Observable<void>;
+    get component(): ComponentRef<unknown> | null;
+    get drag$(): Observable<MoveEvent>;
+    get dragEnd$(): Observable<void>;
+    get dragStart$(): Observable<void>;
+    get element(): HTMLElement;
+    get height(): number;
+    get popupRef(): PopupRef;
+    get resize$(): Observable<ResizeEvent>;
+    get width(): number;
+}
+
+interface WindowActionTemplateContext {
+    $implicit: WindowRef;
+}
+
+interface WindowSettings {
+    actionTemplate?: TemplateRef<WindowActionTemplateContext>;
+    closable?: boolean;
+    closeOnEscape?: boolean;
+    content?: TemplateRef<unknown> | Type<unknown>;
+    draggable?: boolean;
+    focusedElement?: HTMLElement | ElementRef<HTMLElement> | string | null;
+    footerTemplate?: TemplateRef<unknown>;
+    height?: number;
+    left?: number;
+    look?: WindowVariantProps["look"];
+    maxHeight?: number;
+    maxWidth?: number;
+    maximizable?: boolean;
+    minHeight?: number;
+    minWidth?: number;
+    minimizable?: boolean;
+    modal?: boolean;
+    preventClose?: Action<PopupCloseEvent, boolean>;
+    resizable?: boolean;
+    rounded: WindowVariantProps["rounded"];
+    title?: string | TemplateRef<unknown>;
+    top?: number;
+    width?: number;
+    windowClass?: string | string[];
+}
+
+declare class WindowService {
+    #private;
+    open(settings: WindowSettings): WindowRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindowService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WindowService>;
+}
+
+export { WindowActionTemplateDirective, WindowComponent, WindowContentTemplateDirective, WindowFooterTemplateDirective, WindowRef, WindowService, WindowTitleTemplateDirective };
+export type { MoveEvent, ResizeEvent, WindowActionTemplateContext, WindowSettings, WindowVariantProps };

package/types/nanahoshi-mona-ui.d.ts

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