@nanahoshi/mona-ui 0.1.0

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

@@ -0,0 +1,386 @@
+import * as i0 from '@angular/core';
+import { PipeTransform, Signal } from '@angular/core';
+import { Predicate, ImmutableDictionary } from '@mirei/ts-collections';
+
+type SelectionMode = "single" | "multiple";
+
+type ScrollDirection = "left" | "right";
+
+type ColorMode = "hsv" | "rgb";
+type ColorOutputFormat = "hex" | "rgb" | "hsl";
+
+type DataType = "string" | "number" | "date" | "boolean";
+
+declare class PreventableEvent<E extends Event = Event> {
+    #private;
+    constructor(type?: string, event?: E);
+    isDefaultPrevented(): boolean;
+    preventDefault(): void;
+    get originalEvent(): E | undefined;
+    get type(): string | undefined;
+}
+
+declare class FilterChangeEvent extends PreventableEvent {
+    #private;
+    constructor(filterText: string);
+    get filter(): string;
+}
+
+type FilterOperator = "contains" | "endsWith" | "startsWith" | ((value: string, filter: string) => boolean);
+interface FilterableOptions {
+    caseSensitive: boolean;
+    debounce: number;
+    enabled: boolean;
+    operator: FilterOperator;
+}
+
+type Orientation = "horizontal" | "vertical";
+
+type PaletteType = "flat" | "material" | "websafe";
+
+type Position = "top" | "right" | "bottom" | "left";
+
+interface VirtualScrollOptions {
+    enabled: boolean;
+    height?: number;
+}
+
+declare class AnyPipe implements PipeTransform {
+    transform<T>(sequence: Iterable<T> | null | undefined, predicate?: Predicate<T>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AnyPipe, "monaAny", true>;
+}
+
+declare class ContainsPipe implements PipeTransform {
+    transform<T>(sequence: Iterable<T> | null | undefined, value: T | Iterable<T>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContainsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ContainsPipe, "monaContains", true>;
+}
+
+declare class SlicePipe implements PipeTransform {
+    transform<T>(value: Iterable<T>, start: number, end: number): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlicePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SlicePipe, "monaSlice", true>;
+}
+
+declare class TakeFirstPipe implements PipeTransform {
+    transform<T>(value: Iterable<T> | null | undefined): T | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TakeFirstPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TakeFirstPipe, "monaTakeFirst", true>;
+}
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type BuiltIn = Primitive | Date | RegExp | Function | Map<unknown, unknown> | Set<unknown>;
+type DeepPartial<T> = T extends BuiltIn ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+type Path<T> = T extends object ? {
+    [K in keyof T]-?: [
+        K
+    ] | (Path<T[K]> extends infer P ? (P extends ReadonlyArray<PropertyKey> ? [K, ...P] : never) : never);
+}[keyof T] : never;
+type PathValue<T, P> = P extends readonly [infer K, ...infer R] ? K extends keyof T ? R["length"] extends 0 ? T[K] : PathValue<T[K], Extract<R, ReadonlyArray<PropertyKey>>> : never : never;
+type ArrayStrategy = {
+    kind: "replace";
+} | {
+    kind: "concat";
+} | {
+    kind: "unionBy";
+    key: string | string[];
+};
+interface DeepMergeOptions {
+    arrayStrategy?: ArrayStrategy | ((key: PropertyKey, path: ReadonlyArray<PropertyKey>) => ArrayStrategy);
+}
+declare const isEmptyObject: (obj: Record<PropertyKey, unknown>) => boolean;
+declare const isPlainObject: (v: unknown) => v is Record<PropertyKey, unknown>;
+declare function deepMerge<T>(base: T, patch: DeepPartial<T>, options?: DeepMergeOptions, path?: ReadonlyArray<PropertyKey>): T;
+declare function deepMerge<T>(base: DeepPartial<T>, patch: DeepPartial<T>, options?: DeepMergeOptions, path?: ReadonlyArray<PropertyKey>): DeepPartial<T>;
+declare function mergeInto<T>(base: T, patch: DeepPartial<T>, options?: DeepMergeOptions): T;
+declare function mergePatchInto<T>(base: DeepPartial<T>, patch: DeepPartial<T>, options?: DeepMergeOptions): DeepPartial<T>;
+declare function buildNested(keys: ReadonlyArray<PropertyKey>, leaf: unknown): Record<PropertyKey, unknown>;
+declare function patchAt<T, P extends Path<T>>(path: P, value: PathValue<T, P>): DeepPartial<T>;
+declare function setAt<T, P extends Path<T>>(obj: T, path: P, value: PathValue<T, P>, options?: DeepMergeOptions): T;
+declare function prunePatch<T>(base: T, patch: DeepPartial<T>): DeepPartial<T> | undefined;
+declare function prunePatch<T>(base: DeepPartial<T>, patch: DeepPartial<T>): DeepPartial<T> | undefined;
+declare function deepEquals<T>(o1: T, o2: T): boolean;
+
+/**
+ * Determines how the store responds when the base signal emits a new value
+ * while uncommitted drafts exist.
+ *
+ * - `'wipe'`     — Discard all drafts (default). Safe and predictable; the
+ *                  caller is responsible for committing before the base updates.
+ * - `'preserve'` — Keep drafts entirely untouched. Useful when you control
+ *                  base updates and know they are unrelated to in-progress edits.
+ * - `'rebase'`   — Prune the existing draft against the new base, retaining
+ *                  only the fields that still differ from it. Useful for
+ *                  polling scenarios where the server may have accepted some
+ *                  changes but not others.
+ */
+type BaseChangeStrategy = "wipe" | "preserve" | "rebase";
+interface ObjectPatchStoreOptions<T> {
+    /**
+     * Controls what happens to uncommitted drafts when the base signal emits
+     * a new value. Defaults to `'wipe'`.
+     */
+    baseChangeStrategy?: BaseChangeStrategy;
+    /**
+     * Optional initial draft/committed state to hydrate the store with
+     * (e.g. when restoring persisted form state).
+     */
+    initial?: () => DeepPartial<T>;
+    /** Default merge options applied to all patch operations unless overridden per-call. */
+    mergeOptions?: DeepMergeOptions;
+    /** Factory that returns the authoritative base signal for this store. */
+    source: () => Signal<T>;
+}
+interface IObjectPatchStore<T> {
+    /**
+     * Emits the current draft patch, or `undefined` when there are no
+     * pending changes (i.e. the draft is an empty object).
+     */
+    readonly changes: Signal<DeepPartial<T> | undefined>;
+    /**
+     * `true` when the current draft is structurally equal to the last
+     * committed snapshot, i.e. no unsaved changes exist relative to the
+     * last commit point.
+     */
+    readonly pristine: Signal<boolean>;
+    /**
+     * The live merged view of base + draft. Prefer `select()` over reading
+     * this directly in computed signals when you only care about a specific
+     * slice of the object, to avoid unnecessary downstream invalidations.
+     */
+    readonly view: Signal<T>;
+    /**
+     * Discard the current draft without affecting the committed snapshot.
+     * The view reverts to the base value.
+     */
+    clear(): void;
+    /**
+     * Promote the current draft to the committed snapshot.
+     * `pristine` will become `true` immediately after calling this.
+     */
+    commit(): void;
+    /** Returns the last committed draft snapshot. */
+    getCommitted(): DeepPartial<T>;
+    /**
+     * Returns `true` if there is a non-empty draft currently in progress.
+     */
+    hasDraft(): boolean;
+    /**
+     * Deep-merge `patch` into the current draft. Only the fields present in
+     * `patch` are affected; all other fields retain their current draft or
+     * base values. Automatically prunes fields that match the base value so
+     * the draft stays minimal.
+     */
+    patch(patch: DeepPartial<T>, options?: DeepMergeOptions): void;
+    /**
+     * Convenience wrapper over `patch` that builds the patch object from a
+     * type-safe path + value pair.
+     *
+     * @example
+     * store.patchPath(['address', 'city'], 'London');
+     */
+    patchPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
+    /**
+     * Discard both the draft and the committed snapshot, fully resetting
+     * the store to a pristine, empty state.
+     */
+    reset(): void;
+    /**
+     * Directly replace the draft with the given patch object, bypassing the
+     * merge logic. Use with care — this does not prune against the base.
+     * Prefer `patch()` for most use cases.
+     */
+    setDraft(patch: DeepPartial<T>): void;
+    /**
+     * Convenience wrapper over `patch` that sets a single path to a value.
+     * Unlike the old implementation, this merges rather than replaces the
+     * draft, so unrelated draft fields are preserved.
+     *
+     * @example
+     * store.setPath(['address', 'city'], 'London');
+     */
+    setPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
+    /**
+     * Returns a `Signal` that emits only the slice of `view` selected by
+     * `projector`. Uses `deepEquals` as the equality function, so downstream
+     * computeds are only invalidated when the projected value structurally
+     * changes — not on every `view` emission.
+     *
+     * Prefer this over `computed(() => store.view().someField)` when the
+     * downstream work (e.g. a component re-render) is expensive relative to
+     * a `deepEquals` check on the projected slice.
+     *
+     * An optional custom `equal` function can be supplied when `deepEquals`
+     * is too broad or too expensive for the projected type.
+     *
+     * @example
+     * readonly city = store.select(v => v.address.city);
+     */
+    select<R>(projector: (view: T) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
+}
+declare class ObjectPatchStore<T> implements IObjectPatchStore<T> {
+    #private;
+    readonly changes: Signal<DeepPartial<T> | undefined>;
+    readonly pristine: Signal<boolean>;
+    readonly view: Signal<T>;
+    constructor(options: ObjectPatchStoreOptions<T>);
+    clear(): void;
+    commit(): void;
+    getCommitted(): DeepPartial<T>;
+    hasDraft(): boolean;
+    patch(patch: DeepPartial<T>, options?: DeepMergeOptions): void;
+    patchPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
+    reset(): void;
+    setDraft(patch: DeepPartial<T>): void;
+    setPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
+    select<R>(projector: (view: T) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
+}
+interface IterablePatchStoreOptions<TItem, TId> {
+    /** Extracts the stable identity key from an item. */
+    idOf: (item: TItem) => TId;
+    /**
+     * Optional initial draft/committed state (e.g. for restoring persisted
+     * per-row edits). Accepts either a `Map` or an `ImmutableDictionary`.
+     */
+    initial?: () => Map<TId, DeepPartial<TItem>> | ImmutableDictionary<TId, DeepPartial<TItem>>;
+    /** Factory that returns the authoritative base signal for this store. */
+    source: () => Signal<Iterable<TItem>>;
+    /**
+     * Controls what happens to uncommitted drafts when the base signal emits
+     * a new value. Defaults to `'wipe'`.
+     */
+    baseChangeStrategy?: BaseChangeStrategy;
+}
+interface IIterablePatchStore<TItem, TId> {
+    /**
+     * Emits the subset of items that have a non-empty draft, each merged
+     * with its current draft. Items without a draft are excluded.
+     */
+    readonly changes: Signal<TItem[]>;
+    /**
+     * `true` when every item's current draft is structurally equal to its
+     * last committed snapshot.
+     */
+    readonly pristine: Signal<boolean>;
+    /**
+     * The live merged view of all base items with their drafts applied.
+     * Items without a draft are returned as-is (same reference).
+     * Prefer `select()` over reading this directly in computed signals when
+     * you only care about a specific slice.
+     */
+    readonly view: Signal<TItem[]>;
+    /**
+     * Discard the draft for the item identified by `id`.
+     * Has no effect if the item has no draft.
+     */
+    clear(id: TId): void;
+    /** Discard all drafts for all items. */
+    clearAll(): void;
+    /**
+     * Promote all current drafts to the committed snapshot.
+     * `pristine` will become `true` immediately after calling this.
+     */
+    commit(): void;
+    /** Returns the number of items that currently have a non-empty draft. */
+    dirtyCount(): number;
+    /** Returns the last committed drafts dictionary. */
+    getCommitted(): ImmutableDictionary<TId, DeepPartial<TItem>>;
+    /**
+     * Returns `true` if the item identified by `id` has a non-empty draft.
+     */
+    hasDraft(id: TId): boolean;
+    /**
+     * Deep-merge `patch` into the draft for the item identified by `id`.
+     * Automatically prunes fields that now match the base item so the draft
+     * stays minimal. Removes the draft entry entirely if it becomes empty.
+     */
+    patch(id: TId, patch: DeepPartial<TItem>, options?: DeepMergeOptions): void;
+    /**
+     * Apply multiple patches in a single atomic update. Each tuple is
+     * `[id, patch]`. More efficient than calling `patch()` in a loop.
+     * Also prunes each resulting draft against the base item.
+     */
+    patchMany(patchTuple: Iterable<[TId, DeepPartial<TItem>]>, options?: DeepMergeOptions): void;
+    /**
+     * Convenience wrapper over `patch` that builds the patch object from a
+     * type-safe path + value pair for a specific item.
+     *
+     * @example
+     * store.patchPath(itemId, ['address', 'city'], 'London');
+     */
+    patchPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
+    /**
+     * Discard all drafts and committed snapshots, fully resetting the store
+     * to a pristine, empty state.
+     */
+    reset(): void;
+    /**
+     * Directly replace the draft for `id` with the given patch object,
+     * bypassing the merge logic. Use with care — this does not prune against
+     * the base item. Prefer `patch()` for most use cases.
+     */
+    setDraft(id: TId, patch: DeepPartial<TItem>): void;
+    /**
+     * Convenience wrapper over `patch` that sets a single path to a value
+     * for a specific item. Merges into the existing draft rather than
+     * replacing it, so unrelated draft fields are preserved.
+     *
+     * @example
+     * store.setPath(itemId, ['address', 'city'], 'London');
+     */
+    setPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
+    /**
+     * Returns a `Signal` that emits only the slice of `view` selected by
+     * `projector`. Uses `deepEquals` as the equality function by default,
+     * so downstream computeds are only invalidated when the projected value
+     * structurally changes — not on every `view` emission.
+     *
+     * An optional custom `equal` function can be supplied when `deepEquals`
+     * is too broad or too expensive for the projected type.
+     *
+     * @example
+     * readonly cities = store.select(items => items.map(i => i.address.city));
+     */
+    select<R>(projector: (view: TItem[]) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
+}
+declare class IterablePatchStore<TItem, TId> implements IIterablePatchStore<TItem, TId> {
+    #private;
+    readonly changes: Signal<TItem[]>;
+    readonly pristine: Signal<boolean>;
+    readonly view: Signal<TItem[]>;
+    constructor(options: IterablePatchStoreOptions<TItem, TId>);
+    clear(id: TId): void;
+    clearAll(): void;
+    commit(): void;
+    dirtyCount(): number;
+    getCommitted(): ImmutableDictionary<TId, DeepPartial<TItem>>;
+    hasDraft(id: TId): boolean;
+    patch(id: TId, patch: DeepPartial<TItem>, options?: DeepMergeOptions): void;
+    patchMany(patchTuple: Iterable<[TId, DeepPartial<TItem>]>, options?: DeepMergeOptions): void;
+    patchPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
+    reset(): void;
+    setDraft(id: TId, patch: DeepPartial<TItem>): void;
+    setPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
+    select<R>(projector: (view: TItem[]) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
+}
+declare const createIterablePatchStore: <TItem, TId>(options: IterablePatchStoreOptions<TItem, TId>) => IIterablePatchStore<TItem, TId>;
+declare const createObjectPatchStore: <T>(options: ObjectPatchStoreOptions<T>) => IObjectPatchStore<T>;
+
+/**
+ * Calculates the percentage of a value within a given range, rounded to the specified precision.
+ * @param value The current value.
+ * @param min The minimum value.
+ * @param max The maximum value.
+ * @param precision The number of decimal places to round the percentage to.
+ * @default 2
+ * @returns The percentage of the value within the range, rounded to the specified precision.
+ */
+declare const getPercentage: (value: number, min: number, max: number, precision?: number) => number;
+
+declare function moveIndices<T>(array: T[], indices: number[], offset: number): T[];
+
+export { AnyPipe, ContainsPipe, FilterChangeEvent, IterablePatchStore, ObjectPatchStore, PreventableEvent, SlicePipe, TakeFirstPipe, buildNested, createIterablePatchStore, createObjectPatchStore, deepEquals, deepMerge, getPercentage, isEmptyObject, isPlainObject, mergeInto, mergePatchInto, moveIndices, patchAt, prunePatch, setAt };
+export type { ArrayStrategy, BaseChangeStrategy, ColorMode, ColorOutputFormat, DataType, DeepMergeOptions, DeepPartial, FilterOperator, FilterableOptions, IIterablePatchStore, IObjectPatchStore, IterablePatchStoreOptions, ObjectPatchStoreOptions, Orientation, PaletteType, Path, PathValue, Position, ScrollDirection, SelectionMode, VirtualScrollOptions };

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

@@ -0,0 +1,129 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import { PopupMenuVariantInput, PopupMenuItem, PopupMenuComponent, PopupMenuItemClickEvent, PopupMenuGroupComponent, PopupMenuOrigin, PopupMenuCheckboxItemComponent, PopupMenuItemComponent, PopupMenuRadioGroupComponent, PopupMenuRadioItemComponent, PopupMenuSeparatorComponent, PopupMenuGroupTemplateDirective, PopupMenuTemplateOrigin, PopupMenuIconTemplateDirective, PopupMenuShortcutTemplateDirective, PopupMenuTextTemplateDirective } from '@nanahoshi/mona-ui/popup-menu';
+
+type ContextMenuVariantInput = PopupMenuVariantInput;
+
+declare class ContextMenuComponent implements ContextMenuVariantInput {
+    #private;
+    private readonly menuItemComponents;
+    protected readonly groupTemplate: i0.Signal<TemplateRef<any> | undefined>;
+    protected readonly iconTemplate: i0.Signal<TemplateRef<any> | undefined>;
+    protected readonly menuId: string;
+    protected readonly menuItems: i0.Signal<Iterable<PopupMenuItem>>;
+    protected readonly popupMenuRef: i0.Signal<PopupMenuComponent | undefined>;
+    protected readonly shortcutTemplate: i0.Signal<TemplateRef<any> | undefined>;
+    protected readonly textTemplate: i0.Signal<TemplateRef<any> | undefined>;
+    /**
+     * @description Reserved for an ARIA label on the context menu.
+     * Not currently applied to the target element or the rendered menu.
+     */
+    readonly ariaLabel: i0.InputSignal<string>;
+    /**
+     * @description The menu items to render. When provided, these take precedence over
+     * content-projected `mona-contextmenu-item` (and related) components.
+     */
+    readonly items: i0.InputSignal<Iterable<PopupMenuItem>>;
+    /**
+     * @description Emits when a menu item is clicked.
+     */
+    readonly menuClick: i0.OutputEmitterRef<PopupMenuItemClickEvent>;
+    /**
+     * @description Sets the minimum width of the context menu.
+     * This will be applied to the root menu and all submenus.
+     */
+    readonly minWidth: i0.InputSignal<string | number | undefined>;
+    /**
+     * @description Sets the rounded state of the context menu.
+     */
+    readonly rounded: i0.InputSignal<"small" | "medium" | "large" | "none" | null | undefined>;
+    /**
+     * @description Sets the size of the context menu.
+     */
+    readonly size: i0.InputSignal<"small" | "medium" | "large" | null | undefined>;
+    /**
+     * @description The target element that will be used to trigger the context menu.
+     */
+    readonly target: i0.InputSignal<HTMLElement | ElementRef<HTMLElement>>;
+    /**
+     * @description Sets the width of the context menu.
+     * This will be applied to the root menu and all submenus.
+     */
+    readonly width: i0.InputSignal<string | number | undefined>;
+    constructor();
+    protected onMenuClose(): void;
+    protected onMenuOpen(): void;
+    private openMenuViaKeyboard;
+    private setKeyboardEvents;
+    private setTargetAriaAttributes;
+    private updateTargetAriaAttributes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "mona-contextmenu", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "menuClick": "menuClick"; }, ["menuItemComponents", "groupTemplate", "iconTemplate", "shortcutTemplate", "textTemplate"], never, true, never>;
+}
+
+declare class ContextMenuGroupComponent extends PopupMenuGroupComponent {
+    readonly origin = PopupMenuOrigin.ContextMenu;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuGroupComponent, "mona-contextmenu-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuCheckboxItemComponent extends PopupMenuCheckboxItemComponent {
+    readonly origin = PopupMenuOrigin.ContextMenu;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuCheckboxItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuCheckboxItemComponent, "mona-contextmenu-checkbox-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuItemComponent extends PopupMenuItemComponent {
+    readonly origin = PopupMenuOrigin.ContextMenu;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuItemComponent, "mona-contextmenu-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuRadioGroupComponent extends PopupMenuRadioGroupComponent {
+    readonly origin = PopupMenuOrigin.ContextMenu;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuRadioGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuRadioGroupComponent, "mona-contextmenu-radio-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuRadioItemComponent extends PopupMenuRadioItemComponent {
+    readonly origin = PopupMenuOrigin.ContextMenu;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuRadioItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuRadioItemComponent, "mona-contextmenu-radio-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuSeparatorComponent extends PopupMenuSeparatorComponent {
+    readonly origin = PopupMenuOrigin.ContextMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuSeparatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuSeparatorComponent, "mona-contextmenu-separator", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuGroupTemplateDirective extends PopupMenuGroupTemplateDirective {
+    readonly origin = PopupMenuTemplateOrigin.ContextMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuGroupTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuGroupTemplateDirective, "ng-template[monaContextMenuGroupTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuIconTemplateDirective extends PopupMenuIconTemplateDirective {
+    readonly origin = PopupMenuTemplateOrigin.ContextMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuIconTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuIconTemplateDirective, "ng-template[monaContextMenuIconTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuShortcutTemplateDirective extends PopupMenuShortcutTemplateDirective {
+    readonly origin = PopupMenuTemplateOrigin.ContextMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuShortcutTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuShortcutTemplateDirective, "ng-template[monaContextMenuShortcutTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuTextTemplateDirective extends PopupMenuTextTemplateDirective {
+    readonly origin = PopupMenuTemplateOrigin.ContextMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTextTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuTextTemplateDirective, "ng-template[monaContextMenuTextTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+export { ContextMenuCheckboxItemComponent, ContextMenuComponent, ContextMenuGroupComponent, ContextMenuGroupTemplateDirective, ContextMenuIconTemplateDirective, ContextMenuItemComponent, ContextMenuRadioGroupComponent, ContextMenuRadioItemComponent, ContextMenuSeparatorComponent, ContextMenuShortcutTemplateDirective, ContextMenuTextTemplateDirective };

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

@@ -0,0 +1,60 @@
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { Predicate, ImmutableSet } from '@mirei/ts-collections';
+import { DateTime } from 'luxon';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantInputs } from '@nanahoshi/mona-ui/internal';
+import { ThemeStyle } from '@nanahoshi/mona-ui/theme';
+import { VariantProps } from 'class-variance-authority';
+import { Subject } from 'rxjs';
+import { PreventableEvent } from '@nanahoshi/mona-ui/common';
+
+declare class DateInputPrefixTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateInputPrefixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateInputPrefixTemplateDirective, "ng-template[monaDateInputPrefixTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+type CalendarView = "decade" | "month" | "year";
+
+type DateDisabledType = Iterable<Date> | Predicate<Date> | null | undefined;
+
+type HourFormat = "12" | "24";
+
+type Meridiem = "AM" | "PM";
+
+interface TimeUnit {
+    value: number;
+    viewValue: number;
+}
+
+declare class TimeLimiterPipe implements PipeTransform {
+    transform(timeValues: Iterable<TimeUnit>, type: "h" | "m" | "s", currentDate: DateTime, min?: DateTime | null, max?: DateTime | null): ImmutableSet<TimeUnit>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeLimiterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeLimiterPipe, "timeLimiter", true>;
+}
+
+declare const datePopupThemeVariants: (theme: ThemeStyle) => (props?: ({
+    rounded?: "none" | "small" | "medium" | "large" | "full" | null | undefined;
+    size?: "small" | "medium" | "large" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type DatePopupVariantProps = VariantProps<ReturnType<typeof datePopupThemeVariants>>;
+type DatePopupVariantInput = VariantInputs<DatePopupVariantProps>;
+
+declare class CalendarService {
+    readonly keydown$: Subject<PreventableEvent<KeyboardEvent>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarService>;
+}
+
+declare class TimeSelectorService {
+    readonly keydown$: Subject<PreventableEvent<KeyboardEvent>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeSelectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimeSelectorService>;
+}
+
+declare const generateHourSet: (hourFormat: HourFormat, meridiem: Meridiem, step?: number) => ImmutableSet<TimeUnit>;
+declare const generateMinuteSet: (step?: number) => ImmutableSet<TimeUnit>;
+declare const generateSecondSet: (step?: number) => ImmutableSet<TimeUnit>;
+
+export { CalendarService, DateInputPrefixTemplateDirective, TimeLimiterPipe, TimeSelectorService, datePopupThemeVariants, generateHourSet, generateMinuteSet, generateSecondSet };
+export type { CalendarView, DateDisabledType, DatePopupVariantInput, DatePopupVariantProps, HourFormat, Meridiem, TimeUnit };