yukit-web 0.0.1

package/types/yukit-web-helm-item.d.ts

@@ -0,0 +1,96 @@
+import * as i0 from '@angular/core';
+import { ValueProvider } from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as i1 from '@spartan-ng/brain/separator';
+
+declare const itemVariants: (props?: ({
+    variant?: "default" | "outline" | "muted" | null | undefined;
+    size?: "default" | "sm" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ItemVariants = VariantProps<typeof itemVariants>;
+declare class HlmItem {
+    private readonly _config;
+    readonly variant: i0.InputSignal<"default" | "outline" | "muted" | null | undefined>;
+    readonly size: i0.InputSignal<"default" | "sm" | "xs" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItem, "[hlmItem],hlm-item", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmItemActions {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemActions, "[hlmItemActions],hlm-item-actions", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemContent, "[hlmItemContent],hlm-item-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemDescription, "[hlmItemDescription],hlm-item-description", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemFooter, "[hlmItemFooter],hlm-item-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemGroup, "[hlmItemGroup],hlm-item-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmItemHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemHeader, "[hlmItemHeader],hlm-item-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const itemMediaVariants: (props?: ({
+    variant?: "default" | "icon" | "image" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ItemMediaVariants = VariantProps<typeof itemMediaVariants>;
+declare class HlmItemMedia {
+    private readonly _config;
+    readonly variant: i0.InputSignal<"default" | "icon" | "image" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemMedia, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemMedia, "[hlmItemMedia],hlm-item-media", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmItemSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemSeparator, "[hlmItemSeparator],hlm-item-separator", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSeparator; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+declare class HlmItemTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmItemTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmItemTitle, "[hlmItemTitle],hlm-item-title", never, {}, {}, never, never, true, never>;
+}
+
+interface HlmItemConfig {
+    variant: ItemVariants['variant'];
+    size: ItemVariants['size'];
+}
+declare function provideHlmItemConfig(config: Partial<HlmItemConfig>): ValueProvider;
+declare function injectHlmItemConfig(): HlmItemConfig;
+interface HlmItemMediaConfig {
+    variant: ItemMediaVariants['variant'];
+}
+declare function provideHlmItemMediaConfig(config: Partial<HlmItemMediaConfig>): ValueProvider;
+declare function injectHlmItemMediaConfig(): HlmItemMediaConfig;
+
+declare const HlmItemImports: readonly [typeof HlmItem, typeof HlmItemActions, typeof HlmItemContent, typeof HlmItemDescription, typeof HlmItemFooter, typeof HlmItemGroup, typeof HlmItemHeader, typeof HlmItemMedia, typeof HlmItemSeparator, typeof HlmItemTitle];
+
+export { HlmItem, HlmItemActions, HlmItemContent, HlmItemDescription, HlmItemFooter, HlmItemGroup, HlmItemHeader, HlmItemImports, HlmItemMedia, HlmItemSeparator, HlmItemTitle, injectHlmItemConfig, injectHlmItemMediaConfig, provideHlmItemConfig, provideHlmItemMediaConfig };
+export type { HlmItemConfig, HlmItemMediaConfig, ItemMediaVariants, ItemVariants };

package/types/yukit-web-helm-kbd.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from '@angular/core';
+
+declare class HlmKbd {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmKbd, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmKbd, "kbd[hlmKbd]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmKbdGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmKbdGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmKbdGroup, "kbd[hlmKbdGroup]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmKbdImports: readonly [typeof HlmKbd, typeof HlmKbdGroup];
+
+export { HlmKbd, HlmKbdGroup, HlmKbdImports };

package/types/yukit-web-helm-label.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/label';
+
+declare class HlmLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmLabel, "[hlmLabel]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnLabel; inputs: { "id": "id"; "for": "for"; }; outputs: {}; }]>;
+}
+
+declare const HlmLabelImports: readonly [typeof HlmLabel];
+
+export { HlmLabel, HlmLabelImports };

package/types/yukit-web-helm-marker.d.ts

@@ -0,0 +1,31 @@
+import * as i0 from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+declare const markerVariants: (props?: ({
+    variant?: "default" | "separator" | "border" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type MarkerVariants = VariantProps<typeof markerVariants>;
+declare class HlmMarker {
+    readonly variant: i0.InputSignal<"default" | "separator" | "border" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMarker, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMarker, "[hlmMarker],hlm-marker", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmMarkerContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMarkerContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMarkerContent, "[hlmMarkerContent],hlm-marker-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmMarkerIcon {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMarkerIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMarkerIcon, "[hlmMarkerIcon],hlm-marker-icon", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmMarkerImports: readonly [typeof HlmMarker, typeof HlmMarkerContent, typeof HlmMarkerIcon];
+
+export { HlmMarker, HlmMarkerContent, HlmMarkerIcon, HlmMarkerImports };
+export type { MarkerVariants };

package/types/yukit-web-helm-menubar.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from '@angular/core';
+import { ValueProvider } from '@angular/core';
+import * as i1 from '@angular/cdk/menu';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MenuAlign, MenuSide } from '@spartan-ng/brain/core';
+
+declare class HlmMenubar {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMenubar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMenubar, "[hlmMenubar],hlm-menubar", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenuBar; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmMenubarTrigger {
+    private readonly _cdkTrigger;
+    private readonly _config;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly align: i0.InputSignal<MenuAlign>;
+    readonly side: i0.InputSignal<MenuSide>;
+    private readonly _menuPosition;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMenubarTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMenubarTrigger, "button[hlmMenubarTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuItem; inputs: { "cdkMenuItemDisabled": "disabled"; }; outputs: {}; }, { directive: typeof i1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "hlmMenubarTrigger"; "cdkMenuTriggerData": "hlmMenubarTriggerData"; }; outputs: { "cdkMenuOpened": "hlmDropdownMenuOpened"; "cdkMenuClosed": "hlmDropdownMenuClosed"; }; }]>;
+}
+
+interface HlmMenubarConfig {
+    align: MenuAlign;
+    side: MenuSide;
+}
+declare function provideHlmMenubarConfig(config: Partial<HlmMenubarConfig>): ValueProvider;
+declare function injectHlmMenubarConfig(): HlmMenubarConfig;
+
+declare const HlmMenubarImports: readonly [typeof HlmMenubar, typeof HlmMenubarTrigger];
+
+export { HlmMenubar, HlmMenubarImports, HlmMenubarTrigger, injectHlmMenubarConfig, provideHlmMenubarConfig };
+export type { HlmMenubarConfig };

package/types/yukit-web-helm-message.d.ts

@@ -0,0 +1,44 @@
+import * as i0 from '@angular/core';
+
+type MessageAlign = 'start' | 'end';
+declare class HlmMessage {
+    readonly align: i0.InputSignal<MessageAlign>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMessage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMessage, "[hlmMessage],hlm-message", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmMessageAvatar {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMessageAvatar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMessageAvatar, "[hlmMessageAvatar],hlm-message-avatar", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmMessageContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMessageContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMessageContent, "[hlmMessageContent],hlm-message-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmMessageFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMessageFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMessageFooter, "[hlmMessageFooter],hlm-message-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmMessageGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMessageGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMessageGroup, "[hlmMessageGroup],hlm-message-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmMessageHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMessageHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMessageHeader, "[hlmMessageHeader],hlm-message-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmMessageImports: readonly [typeof HlmMessage, typeof HlmMessageAvatar, typeof HlmMessageContent, typeof HlmMessageFooter, typeof HlmMessageGroup, typeof HlmMessageHeader];
+
+export { HlmMessage, HlmMessageAvatar, HlmMessageContent, HlmMessageFooter, HlmMessageGroup, HlmMessageHeader, HlmMessageImports };
+export type { MessageAlign };

package/types/yukit-web-helm-native-select.d.ts

@@ -0,0 +1,65 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor } from '@angular/forms';
+import { ChangeFn, TouchFn } from '@spartan-ng/brain/forms';
+import { ClassValue } from 'clsx';
+import * as i1 from '@spartan-ng/brain/field';
+
+declare const HLM_NATIVE_SELECT_VALUE_ACCESSOR: {
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+};
+declare class HlmNativeSelect implements ControlValueAccessor {
+    private readonly _fieldControl;
+    private static _id;
+    readonly selectId: _angular_core.InputSignal<string>;
+    readonly selectClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedSelectClass: _angular_core.Signal<string>;
+    readonly selectIconClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedSelectIconClass: _angular_core.Signal<string>;
+    readonly size: _angular_core.InputSignal<"sm" | "default">;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    /** Whether to force the input into an invalid state. */
+    readonly forceInvalid: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Manual override for aria-invalid. When not set, auto-detects from the parent autocomplete error state. */
+    readonly ariaInvalidOverride: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    protected readonly _ariaInvalid: _angular_core.Signal<boolean | null | undefined>;
+    readonly valueInput: _angular_core.InputSignal<string | null | undefined>;
+    readonly value: _angular_core.WritableSignal<string | null | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | null | undefined>;
+    protected _onChange?: ChangeFn<string | undefined | null>;
+    protected _onTouched?: TouchFn;
+    readonly labelableId: _angular_core.InputSignal<string>;
+    protected readonly _invalid: _angular_core.Signal<boolean | null> | undefined;
+    protected readonly _touched: _angular_core.Signal<boolean | null> | undefined;
+    protected readonly _dirty: _angular_core.Signal<boolean | null> | undefined;
+    protected readonly _spartanInvalid: _angular_core.Signal<boolean | null | undefined>;
+    constructor();
+    protected _valueChanged(event: Event): void;
+    protected _blur(): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: string | undefined | null): void;
+    registerOnChange(fn: ChangeFn<string | undefined | null>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmNativeSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmNativeSelect, "hlm-native-select", never, { "selectId": { "alias": "selectId"; "required": false; "isSignal": true; }; "selectClass": { "alias": "selectClass"; "required": false; "isSignal": true; }; "selectIconClass": { "alias": "selectIconClass"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; "ariaInvalidOverride": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, [{ directive: typeof i1.BrnFieldControl; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmNativeSelectOptGroup {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmNativeSelectOptGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmNativeSelectOptGroup, "optgroup[hlmNativeSelectOptGroup]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmNativeSelectOption {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmNativeSelectOption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmNativeSelectOption, "option[hlmNativeSelectOption]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmNativeSelectImports: readonly [typeof HlmNativeSelect, typeof HlmNativeSelectOption, typeof HlmNativeSelectOptGroup];
+
+export { HLM_NATIVE_SELECT_VALUE_ACCESSOR, HlmNativeSelect, HlmNativeSelectImports, HlmNativeSelectOptGroup, HlmNativeSelectOption };

package/types/yukit-web-helm-navigation-menu.d.ts

@@ -0,0 +1,49 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/navigation-menu';
+import { NumberInput } from '@angular/cdk/coercion';
+
+declare class HlmNavigationMenu {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenu, "nav[hlmNavigationMenu]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnNavigationMenu; inputs: { "value": "value"; "delayDuration": "delayDuration"; "skipDelayDuration": "skipDelayDuration"; "orientation": "orientation"; "openOn": "openOn"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class HlmNavigationMenuContent {
+    readonly navOffset: i0.InputSignalWithTransform<number, NumberInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuContent, "[hlmNavigationMenuContent],hlm-navigation-menu-content", never, { "navOffset": { "alias": "navOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmNavigationMenuItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuItem, "li[hlmNavigationMenuItem]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnNavigationMenuItem; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuLink {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuLink, "a[hlmNavigationMenuLink]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnNavigationMenuLink; inputs: { "active": "active"; }; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuList {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuList, "ul[hlmNavigationMenuList]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnNavigationMenuList; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmNavigationMenuPortal, "[hlmNavigationMenuPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnNavigationMenuContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmNavigationMenuTrigger {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmNavigationMenuTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmNavigationMenuTrigger, "button[hlmNavigationMenuTrigger]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.BrnNavigationMenuTrigger; inputs: { "align": "align"; }; outputs: {}; }]>;
+}
+
+declare const HlmNavigationMenuImports: readonly [typeof HlmNavigationMenu, typeof HlmNavigationMenuContent, typeof HlmNavigationMenuItem, typeof HlmNavigationMenuLink, typeof HlmNavigationMenuList, typeof HlmNavigationMenuPortal, typeof HlmNavigationMenuTrigger];
+
+export { HlmNavigationMenu, HlmNavigationMenuContent, HlmNavigationMenuImports, HlmNavigationMenuItem, HlmNavigationMenuLink, HlmNavigationMenuList, HlmNavigationMenuPortal, HlmNavigationMenuTrigger };

package/types/yukit-web-helm-pagination.d.ts

@@ -0,0 +1,187 @@
+import * as _angular_core from '@angular/core';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import * as _angular_router from '@angular/router';
+import { ClassValue } from 'clsx';
+
+declare class HlmNumberedPagination {
+    /**
+     * The current (active) page.
+     */
+    readonly currentPage: _angular_core.ModelSignal<number>;
+    /**
+     * The number of items per paginated page.
+     */
+    readonly itemsPerPage: _angular_core.ModelSignal<number>;
+    /**
+     * The total number of items in the collection. Only useful when
+     * doing server-side paging, where the collection size is limited
+     * to a single page returned by the server API.
+     */
+    readonly totalItems: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The number of page links to show.
+     */
+    readonly maxSize: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Show the first and last page buttons.
+     */
+    readonly showEdges: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The page sizes to show.
+     * Defaults to [10, 20, 50, 100]
+     */
+    readonly pageSizes: _angular_core.InputSignal<number[]>;
+    protected readonly _pageSizesWithCurrent: _angular_core.Signal<number[]>;
+    protected readonly _isFirstPageActive: _angular_core.Signal<boolean>;
+    protected readonly _isLastPageActive: _angular_core.Signal<boolean>;
+    protected readonly _lastPageNumber: _angular_core.Signal<number>;
+    protected readonly _pages: _angular_core.Signal<Page[]>;
+    protected goToPrevious(): void;
+    protected goToNext(): void;
+    protected goToFirst(): void;
+    protected goToLast(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmNumberedPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmNumberedPagination, "hlm-numbered-pagination", never, { "currentPage": { "alias": "currentPage"; "required": true; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": true; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": true; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "showEdges": { "alias": "showEdges"; "required": false; "isSignal": true; }; "pageSizes": { "alias": "pageSizes"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "itemsPerPage": "itemsPerPageChange"; }, never, never, true, never>;
+}
+type Page = number | '...';
+/**
+ * Checks that the instance.currentPage property is within bounds for the current page range.
+ * If not, return a correct value for currentPage, or the current value if OK.
+ *
+ * Copied from 'ngx-pagination' package
+ */
+declare function outOfBoundCorrection(totalItems: number, itemsPerPage: number, currentPage: number): number;
+/**
+ * Returns an array of Page objects to use in the pagination controls.
+ *
+ * Copied from 'ngx-pagination' package
+ */
+declare function createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): Page[];
+
+declare class HlmNumberedPaginationQueryParams {
+    /**
+     * The current (active) page.
+     */
+    readonly currentPage: _angular_core.ModelSignal<number>;
+    /**
+     * The number of items per paginated page.
+     */
+    readonly itemsPerPage: _angular_core.ModelSignal<number>;
+    /**
+     * The total number of items in the collection. Only useful when
+     * doing server-side paging, where the collection size is limited
+     * to a single page returned by the server API.
+     */
+    readonly totalItems: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The URL path to use for the pagination links.
+     * Defaults to '.' (current path).
+     */
+    readonly link: _angular_core.InputSignal<string>;
+    /**
+     * The number of page links to show.
+     */
+    readonly maxSize: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Show the first and last page buttons.
+     */
+    readonly showEdges: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The page sizes to show.
+     * Defaults to [10, 20, 50, 100]
+     */
+    readonly pageSizes: _angular_core.InputSignal<number[]>;
+    protected readonly _pageSizesWithCurrent: _angular_core.Signal<number[]>;
+    protected readonly _isFirstPageActive: _angular_core.Signal<boolean>;
+    protected readonly _isLastPageActive: _angular_core.Signal<boolean>;
+    protected readonly _lastPageNumber: _angular_core.Signal<number>;
+    protected readonly _pages: _angular_core.Signal<(number | "...")[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmNumberedPaginationQueryParams, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmNumberedPaginationQueryParams, "hlm-numbered-pagination-query-params", never, { "currentPage": { "alias": "currentPage"; "required": true; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": true; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": true; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "showEdges": { "alias": "showEdges"; "required": false; "isSignal": true; }; "pageSizes": { "alias": "pageSizes"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "itemsPerPage": "itemsPerPageChange"; }, never, never, true, never>;
+}
+
+declare class HlmPagination {
+    /** The aria-label for the pagination component. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmPagination, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmPagination, "[hlmPagination],hlm-pagination", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationContent {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmPaginationContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmPaginationContent, "ul[hlmPaginationContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationEllipsis {
+    /** Screen reader only text for the ellipsis */
+    readonly srOnlyText: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmPaginationEllipsis, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmPaginationEllipsis, "hlm-pagination-ellipsis", never, { "srOnlyText": { "alias": "srOnlyText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationItem {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmPaginationItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmPaginationItem, "li[hlmPaginationItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationLink {
+    /** Whether the link is active (i.e., the current page). */
+    readonly isActive: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The size of the button. */
+    readonly size: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    /** The link to navigate to the page. */
+    readonly link: _angular_core.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmPaginationLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmPaginationLink, "[hlmPaginationLink]", never, { "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _angular_router.RouterLink; inputs: { "target": "target"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "state": "state"; "info": "info"; "relativeTo": "relativeTo"; "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; "routerLink": "link"; }; outputs: {}; }]>;
+}
+
+declare class HlmPaginationNext {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    /** The link to navigate to the next page. */
+    readonly link: _angular_core.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    /** The query parameters to pass to the next page. */
+    readonly queryParams: _angular_core.InputSignal<_angular_router.Params | null | undefined>;
+    /** How to handle query parameters when navigating to the next page. */
+    readonly queryParamsHandling: _angular_core.InputSignal<_angular_router.QueryParamsHandling | null | undefined>;
+    /** The aria-label for the next page link. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** The text to display for the next page link. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Whether the button should only display the icon. */
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _labelClass: _angular_core.Signal<"sr-only" | "hidden sm:block">;
+    protected readonly _size: _angular_core.Signal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmPaginationNext, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmPaginationNext, "hlm-pagination-next", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmPaginationPrevious {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    /** The link to navigate to the previous page. */
+    readonly link: _angular_core.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    /** The query parameters to pass to the previous page. */
+    readonly queryParams: _angular_core.InputSignal<_angular_router.Params | null | undefined>;
+    /** How to handle query parameters when navigating to the previous page. */
+    readonly queryParamsHandling: _angular_core.InputSignal<_angular_router.QueryParamsHandling | null | undefined>;
+    /** The aria-label for the previous page link. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** The text to display for the previous page link. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Whether the button should only display the icon. */
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _labelClass: _angular_core.Signal<string>;
+    protected readonly _size: _angular_core.Signal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmPaginationPrevious, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmPaginationPrevious, "hlm-pagination-previous", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmPaginationImports: readonly [typeof HlmPagination, typeof HlmPaginationContent, typeof HlmPaginationItem, typeof HlmPaginationLink, typeof HlmPaginationPrevious, typeof HlmPaginationNext, typeof HlmPaginationEllipsis, typeof HlmNumberedPagination, typeof HlmNumberedPaginationQueryParams];
+
+export { HlmNumberedPagination, HlmNumberedPaginationQueryParams, HlmPagination, HlmPaginationContent, HlmPaginationEllipsis, HlmPaginationImports, HlmPaginationItem, HlmPaginationLink, HlmPaginationNext, HlmPaginationPrevious, createPageArray, outOfBoundCorrection };

package/types/yukit-web-helm-popover.d.ts

@@ -0,0 +1,49 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/popover';
+
+declare class HlmPopover {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopover, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopover, "[hlmPopover],hlm-popover", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnPopover; inputs: { "align": "align"; "attachTo": "attachTo"; "autoFocus": "autoFocus"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "offsetX": "offsetX"; "sideOffset": "sideOffset"; "state": "state"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmPopoverContent {
+    private readonly _stateProvider;
+    state: i0.Signal<"closed" | "open">;
+    private readonly _renderer;
+    private readonly _element;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverContent, "[hlmPopoverContent],hlm-popover-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPopoverDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverDescription, "[hlmPopoverDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPopoverHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverHeader, "[hlmPopoverHeader],hlm-popover-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPopoverPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverPortal, "[hlmPopoverPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnPopoverContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmPopoverTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverTitle, "[hlmPopoverTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmPopoverTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmPopoverTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmPopoverTrigger, "button[hlmPopoverTrigger],button[hlmPopoverTriggerFor]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnPopoverTrigger; inputs: { "id": "id"; "brnPopoverTriggerFor": "hlmPopoverTriggerFor"; "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmPopoverImports: readonly [typeof HlmPopover, typeof HlmPopoverContent, typeof HlmPopoverDescription, typeof HlmPopoverHeader, typeof HlmPopoverPortal, typeof HlmPopoverTitle, typeof HlmPopoverTrigger];
+
+export { HlmPopover, HlmPopoverContent, HlmPopoverDescription, HlmPopoverHeader, HlmPopoverImports, HlmPopoverPortal, HlmPopoverTitle, HlmPopoverTrigger };

package/types/yukit-web-helm-progress.d.ts

@@ -0,0 +1,22 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/progress';
+
+declare class HlmProgress {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmProgress, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmProgress, "hlm-progress,[hlmProgress]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnProgress; inputs: { "value": "value"; "max": "max"; "getValueLabel": "getValueLabel"; }; outputs: {}; }]>;
+}
+
+declare class HlmProgressIndicator {
+    private readonly _progress;
+    private readonly _dir;
+    protected readonly _transform: i0.Signal<string>;
+    protected readonly _indeterminate: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmProgressIndicator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmProgressIndicator, "[hlmProgressIndicator],hlm-progress-indicator", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnProgressIndicator; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmProgressImports: readonly [typeof HlmProgress, typeof HlmProgressIndicator];
+
+export { HlmProgress, HlmProgressImports, HlmProgressIndicator };