primeng 0.0.0-watch

package/stepper/index.d.ts

@@ -0,0 +1,297 @@
+import * as i0 from '@angular/core';
+import { ModelSignal, AfterContentInit, InputSignalWithTransform, TemplateRef, QueryList, InputSignal } from '@angular/core';
+import * as i1 from 'primeng/api';
+import { PrimeTemplate } from 'primeng/api';
+import { BaseComponent } from 'primeng/basecomponent';
+import { BaseStyle } from 'primeng/base';
+
+declare class StepItemStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-stepitem-active': any;
+        })[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepItemStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepItemStyle>;
+}
+interface StepItemStyle extends BaseStyle {
+}
+
+declare class StepListStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepListStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepListStyle>;
+}
+interface StepListStyle extends BaseStyle {
+}
+
+declare class StepPanelsStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepPanelsStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepPanelsStyle>;
+}
+interface StepPanelsStyle extends BaseStyle {
+}
+
+declare class StepPanelStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-steppanel-active': any;
+        })[];
+        content: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepPanelStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepPanelStyle>;
+}
+interface StepPanelStyle extends BaseStyle {
+}
+
+/**
+ *
+ * Stepper is a component that streamlines a wizard-like workflow, organizing content into coherent steps and visually guiding users through a numbered progression in a multi-step process.
+ *
+ * [Live Demo](https://www.primeng.org/stepper/)
+ *
+ * @module stepperstyle
+ *
+ */
+declare enum StepperClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-stepper",
+    /**
+     * Class name of the separator element
+     */
+    separator = "p-stepper-separator"
+}
+declare class StepperStyle extends BaseStyle {
+    name: string;
+    theme: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-readonly': any;
+        })[];
+        separator: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepperStyle>;
+}
+interface StepperStyle extends BaseStyle {
+}
+
+declare class StepStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-step-active': any;
+            'p-disabled': any;
+        })[];
+        header: string;
+        number: string;
+        title: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepStyle>;
+}
+interface StepStyle extends BaseStyle {
+}
+
+/**
+ * Context interface for the StepPanel content template.
+ * @property {() => void} activateCallback - Callback function to activate a step.
+ * @property {number} value - The value associated with the step.
+ * @property {boolean} active - A flag indicating whether the step is active.
+ * @group Interface
+ */
+interface StepContentTemplateContext {
+    activateCallback: () => void;
+    value: number;
+    active: boolean;
+}
+/**
+ * Context interface for the StepPanel content template.
+ * @property {(index: number) => void} activateCallback - Callback function to activate a step.
+ * @property {number} value - The value associated with the step.
+ * @property {boolean} active - A flag indicating whether the step is active.
+ * @group Interface
+ */
+interface StepPanelContentTemplateContext {
+    activateCallback: (index: number) => void;
+    value: number;
+    active: boolean;
+}
+declare class StepList extends BaseComponent {
+    steps: i0.Signal<readonly any[]>;
+    _componentStyle: StepListStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepList, "p-step-list", never, {}, {}, ["steps"], ["*"], true, never>;
+}
+declare class StepperSeparator extends BaseComponent {
+    _componentStyle: StepperStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepperSeparator, "p-stepper-separator", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * StepItem is a helper component for Stepper component used in vertical orientation.
+ * @group Components
+ */
+declare class StepItem extends BaseComponent {
+    pcStepper: any;
+    /**
+     * Value of step.
+     * @type {<number | undefined>}
+     * @defaultValue undefined
+     * @group Props
+     */
+    value: ModelSignal<number | undefined>;
+    isActive: i0.Signal<boolean>;
+    step: i0.Signal<any>;
+    stepPanel: i0.Signal<any>;
+    constructor();
+    _componentStyle: StepItemStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepItem, "p-step-item", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["step", "stepPanel"], ["*"], true, never>;
+}
+/**
+ * Step is a helper component for Stepper component.
+ * @group Components
+ */
+declare class Step extends BaseComponent implements AfterContentInit {
+    pcStepper: any;
+    /**
+     * Active value of stepper.
+     * @type {number}
+     * @defaultValue undefined
+     * @group Props
+     */
+    value: ModelSignal<number>;
+    /**
+     * Whether the step is disabled.
+     * @type {boolean}
+     * @defaultValue false
+     * @group Props
+     */
+    disabled: InputSignalWithTransform<any, boolean>;
+    active: i0.Signal<any>;
+    isStepDisabled: i0.Signal<any>;
+    id: i0.Signal<string>;
+    ariaControls: i0.Signal<string>;
+    isSeparatorVisible: i0.Signal<boolean>;
+    /**
+     * Content template.
+     * @type {TemplateRef<StepContentTemplateContext>}
+     * @group Templates
+     */
+    content: TemplateRef<StepContentTemplateContext>;
+    templates: QueryList<PrimeTemplate> | undefined;
+    _contentTemplate: TemplateRef<any> | undefined;
+    _componentStyle: StepStyle;
+    ngAfterContentInit(): void;
+    onStepClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Step, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Step, "p-step", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["content", "templates"], ["*"], true, never>;
+}
+/**
+ * StepPanel is a helper component for Stepper component.
+ * @group Components
+ */
+declare class StepPanel extends BaseComponent implements AfterContentInit {
+    pcStepper: any;
+    transitionOptions: i0.Signal<any>;
+    /**
+     * Active value of stepper.
+     * @type {number}
+     * @defaultValue undefined
+     * @group Props
+     */
+    value: ModelSignal<number>;
+    active: i0.Signal<boolean>;
+    visible: i0.WritableSignal<boolean>;
+    isVisible: i0.Signal<boolean>;
+    ariaControls: i0.Signal<string>;
+    id: i0.Signal<string>;
+    isVertical: i0.Signal<boolean>;
+    isSeparatorVisible: i0.Signal<boolean>;
+    /**
+     * Content template.
+     * @param {StepPanelContentTemplateContext} context - Context of the template
+     * @see {@link StepPanelContentTemplateContext}
+     * @group Templates
+     */
+    contentTemplate: TemplateRef<StepPanelContentTemplateContext>;
+    templates: QueryList<PrimeTemplate> | undefined;
+    _contentTemplate: TemplateRef<any> | undefined;
+    _componentStyle: StepPanelStyle;
+    ngAfterContentInit(): void;
+    onAnimationStart(event: any): void;
+    onAnimationEnd(event: any): void;
+    updateValue(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepPanel, "p-step-panel", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["contentTemplate", "templates"], never, true, never>;
+}
+declare class StepPanels extends BaseComponent {
+    _componentStyle: StepPanelsStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepPanels, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepPanels, "p-step-panels", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Stepper is a component that streamlines a wizard-like workflow, organizing content into coherent steps and visually guiding users through a numbered progression in a multistep process.
+ * @group Components
+ */
+declare class Stepper extends BaseComponent {
+    /**
+     * A model that can hold a numeric value or be undefined.
+     * @defaultValue undefined
+     * @type {ModelSignal<number | undefined>}
+     * @group Props
+     */
+    value: ModelSignal<number | undefined>;
+    /**
+     * A boolean variable that captures user input.
+     * @defaultValue false
+     * @type {InputSignalWithTransform<any, boolean >}
+     * @group Props
+     */
+    linear: InputSignalWithTransform<any, boolean>;
+    /**
+     * Transition options of the animation.
+     * @defaultValue 400ms cubic-bezier(0.86, 0, 0.07, 1)
+     * @type {InputSignal<string >}
+     * @group Props
+     */
+    transitionOptions: InputSignal<string>;
+    _componentStyle: StepperStyle;
+    id: i0.WritableSignal<string>;
+    stepItems: i0.Signal<readonly StepItem[]>;
+    steps: i0.Signal<readonly Step[]>;
+    stepList: i0.Signal<StepList>;
+    updateValue(value: number): void;
+    isStepActive(value: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Stepper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Stepper, "p-stepper", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "transitionOptions": { "alias": "transitionOptions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["stepItems", "steps", "stepList"], ["*"], true, never>;
+}
+declare class StepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StepperModule, never, [typeof Stepper, typeof StepList, typeof StepPanels, typeof StepPanel, typeof StepItem, typeof Step, typeof StepperSeparator, typeof i1.SharedModule], [typeof Stepper, typeof StepList, typeof StepPanels, typeof StepPanel, typeof StepItem, typeof Step, typeof StepperSeparator, typeof i1.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StepperModule>;
+}
+
+export { Step, StepItem, StepList, StepPanel, StepPanels, Stepper, StepperClasses, StepperModule, StepperSeparator, StepperStyle };
+export type { StepContentTemplateContext, StepPanelContentTemplateContext };

package/steps/index.d.ts

@@ -0,0 +1,152 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, ElementRef } from '@angular/core';
+import { Router, ActivatedRoute } from '@angular/router';
+import * as i1 from 'primeng/api';
+import { MenuItem } from 'primeng/api';
+import { BaseComponent } from 'primeng/basecomponent';
+import { Nullable } from 'primeng/ts-helpers';
+import { Subscription } from 'rxjs';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primeng/base';
+
+/**
+ *
+ * Steps components is an indicator for the steps in a wizard workflow. Example below uses nested routes with Steps.
+ *
+ * [Live Demo](https://www.primeng.org/steps/)
+ *
+ * @module stepsstyle
+ *
+ */
+declare enum StepsClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-steps",
+    /**
+     * Class name of the list element
+     */
+    list = "p-steps-list",
+    /**
+     * Class name of the item element
+     */
+    item = "p-steps-item",
+    /**
+     * Class name of the item link element
+     */
+    itemLink = "p-steps-item-link",
+    /**
+     * Class name of the item number element
+     */
+    itemNumber = "p-steps-item-number",
+    /**
+     * Class name of the item label element
+     */
+    itemLabel = "p-steps-item-label"
+}
+declare class StepsStyle extends BaseStyle {
+    name: string;
+    theme: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-readonly': any;
+        })[];
+        list: string;
+        item: ({ instance, item, index }: {
+            instance: any;
+            item: any;
+            index: any;
+        }) => (string | {
+            'p-steps-item-active': any;
+            'p-disabled': any;
+        })[];
+        itemLink: string;
+        itemNumber: string;
+        itemLabel: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepsStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StepsStyle>;
+}
+interface StepsStyle extends BaseStyle {
+}
+
+/**
+ * Steps components is an indicator for the steps in a wizard workflow.
+ * @group Components
+ */
+declare class Steps extends BaseComponent implements OnInit, OnDestroy {
+    /**
+     * Index of the active item.
+     * @group Props
+     */
+    activeIndex: number;
+    /**
+     * An array of menu items.
+     * @group Props
+     */
+    model: MenuItem[] | undefined;
+    /**
+     * Whether the items are clickable or not.
+     * @group Props
+     */
+    readonly: boolean;
+    /**
+     * Inline style of the component.
+     * @group Props
+     */
+    style: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Style class of the component.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Whether to apply 'router-link-active-exact' class if route exactly matches the item path.
+     * @group Props
+     */
+    exact: boolean;
+    /**
+     * Callback to invoke when the new step is selected.
+     * @param {number} number - current index.
+     * @group Emits
+     */
+    activeIndexChange: EventEmitter<number>;
+    listViewChild: Nullable<ElementRef>;
+    router: Router;
+    route: ActivatedRoute;
+    _componentStyle: StepsStyle;
+    subscription: Subscription | undefined;
+    ngOnInit(): void;
+    onItemClick(event: Event, item: MenuItem, i: number): void;
+    onItemKeydown(event: KeyboardEvent, item: MenuItem, i: number): void;
+    navigateToNextItem(target: any): void;
+    navigateToPrevItem(target: any): void;
+    navigateToFirstItem(target: any): void;
+    navigateToLastItem(target: any): void;
+    findNextItem(item: any): any;
+    findPrevItem(item: any): any;
+    findFirstItem(): Element;
+    findLastItem(): Element;
+    setFocusToMenuitem(target: any, focusableItem: any): void;
+    isClickableRouterLink(item: MenuItem): boolean;
+    isItemDisabled(item: MenuItem, index: number): boolean;
+    isActive(item: MenuItem, index: number): boolean;
+    getItemTabIndex(item: MenuItem, index: number): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Steps, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Steps, "p-steps", never, { "activeIndex": { "alias": "activeIndex"; "required": false; }; "model": { "alias": "model"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "exact": { "alias": "exact"; "required": false; }; }, { "activeIndexChange": "activeIndexChange"; }, never, never, true, never>;
+    static ngAcceptInputType_activeIndex: unknown;
+    static ngAcceptInputType_readonly: unknown;
+    static ngAcceptInputType_exact: unknown;
+}
+declare class StepsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StepsModule, never, [typeof Steps, typeof i1.SharedModule], [typeof Steps, typeof i1.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StepsModule>;
+}
+
+export { Steps, StepsClasses, StepsModule, StepsStyle };

package/styleclass/index.d.ts

@@ -0,0 +1,115 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, ElementRef, Renderer2, NgZone } from '@angular/core';
+import { VoidListener } from 'primeng/ts-helpers';
+
+/**
+ * StyleClass manages css classes declaratively to during enter/leave animations or just to toggle classes on an element.
+ * @group Components
+ */
+declare class StyleClass implements OnDestroy {
+    el: ElementRef;
+    renderer: Renderer2;
+    private zone;
+    constructor(el: ElementRef, renderer: Renderer2, zone: NgZone);
+    /**
+     * Selector to define the target element. Available selectors are '@next', '@prev', '@parent' and '@grandparent'.
+     * @group Props
+     */
+    selector: string | undefined;
+    /**
+     * Style class to add when item begins to get displayed.
+     * @group Props
+     */
+    enterFromClass: string | undefined;
+    /**
+     * Style class to add during enter animation.
+     * @group Props
+     */
+    enterActiveClass: string | undefined;
+    /**
+     * Style class to add when item begins to get displayed.
+     * @group Props
+     */
+    enterToClass: string | undefined;
+    /**
+     * Style class to add when item begins to get hidden.
+     * @group Props
+     */
+    leaveFromClass: string | undefined;
+    /**
+     * Style class to add during leave animation.
+     * @group Props
+     */
+    leaveActiveClass: string | undefined;
+    /**
+     * Style class to add when leave animation is completed.
+     * @group Props
+     */
+    leaveToClass: string | undefined;
+    /**
+     * Whether to trigger leave animation when outside of the element is clicked.
+     * @group Props
+     */
+    hideOnOutsideClick: boolean | undefined;
+    /**
+     * Adds or removes a class when no enter-leave animation is required.
+     * @group Props
+     */
+    toggleClass: string | undefined;
+    /**
+     * Whether to trigger leave animation when escape key pressed.
+     * @group Props
+     */
+    hideOnEscape: boolean | undefined;
+    /**
+     * Whether to trigger leave animation when the target element resized.
+     * @group Props
+     */
+    hideOnResize: boolean | undefined;
+    /**
+     * Target element to listen resize. Valid values are "window", "document" or target element selector.
+     * @group Props
+     */
+    resizeSelector: string | undefined;
+    eventListener: VoidListener;
+    documentClickListener: VoidListener;
+    documentKeydownListener: VoidListener;
+    windowResizeListener: VoidListener;
+    resizeObserver: ResizeObserver | undefined;
+    target: HTMLElement | null | undefined;
+    enterListener: VoidListener;
+    leaveListener: VoidListener;
+    animating: boolean | undefined;
+    _enterClass: string | undefined;
+    _leaveClass: string | undefined;
+    _resizeTarget: any;
+    clickListener(): void;
+    toggle(): void;
+    enter(): void;
+    leave(): void;
+    bindDocumentClickListener(): void;
+    bindDocumentKeydownListener(): void;
+    isVisible(): boolean;
+    isOutsideClick(event: MouseEvent): boolean;
+    unbindDocumentClickListener(): void;
+    unbindDocumentKeydownListener(): void;
+    bindResizeListener(): void;
+    unbindResizeListener(): void;
+    bindWindowResizeListener(): void;
+    unbindWindowResizeListener(): void;
+    bindElementResizeListener(): void;
+    unbindElementResizeListener(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StyleClass, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StyleClass, "[pStyleClass]", never, { "selector": { "alias": "pStyleClass"; "required": false; }; "enterFromClass": { "alias": "enterFromClass"; "required": false; }; "enterActiveClass": { "alias": "enterActiveClass"; "required": false; }; "enterToClass": { "alias": "enterToClass"; "required": false; }; "leaveFromClass": { "alias": "leaveFromClass"; "required": false; }; "leaveActiveClass": { "alias": "leaveActiveClass"; "required": false; }; "leaveToClass": { "alias": "leaveToClass"; "required": false; }; "hideOnOutsideClick": { "alias": "hideOnOutsideClick"; "required": false; }; "toggleClass": { "alias": "toggleClass"; "required": false; }; "hideOnEscape": { "alias": "hideOnEscape"; "required": false; }; "hideOnResize": { "alias": "hideOnResize"; "required": false; }; "resizeSelector": { "alias": "resizeSelector"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_hideOnOutsideClick: unknown;
+    static ngAcceptInputType_hideOnEscape: unknown;
+    static ngAcceptInputType_hideOnResize: unknown;
+}
+declare class StyleClassModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StyleClassModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StyleClassModule, never, [typeof StyleClass], [typeof StyleClass]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StyleClassModule>;
+}
+
+export { StyleClass, StyleClassModule };