@ops-prime/primeng 0.0.0-stage → 21.1.10

package/types/primeng-tabs.d.ts

@@ -0,0 +1,360 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, QueryList, ElementRef } from '@angular/core';
+import { BaseComponent } from 'primeng/basecomponent';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import { TabsPassThrough, TabPanelsPassThrough, TabPanelPassThrough, TabListPassThrough, TabPassThrough } from 'primeng/types/tabs';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primeng/base';
+import { PrimeTemplate } from 'primeng/api';
+import * as i1$1 from 'primeng/ripple';
+
+/**
+ *
+ * Tabs facilitates seamless switching between different views.
+ *
+ * [Live Demo](https://www.primeng.org/tabs/)
+ *
+ * @module tabsstyle
+ *
+ */
+declare enum TabsClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-tabs",
+    /**
+     * Class name of the wrapper element
+     */
+    list = "p-tablist",
+    /**
+     * Class name of the content element
+     */
+    content = "p-tablist-content",
+    /**
+     * Class name of the tab list element
+     */
+    tablist = "p-tablist-tab-list",
+    /**
+     * Class name of the tab list element
+     */
+    tab = "p-tab",
+    /**
+     * Class name of the inkbar element
+     */
+    inkbar = "p-tablist-active-bar",
+    /**
+     * Class name of the navigation buttons
+     */
+    button = "p-tablist-nav-button",
+    /**
+     * Class name of the tab panels wrapper
+     */
+    tabpanels = "p-tabpanels",
+    /**
+     * Class name of the tab panel element
+     */
+    tabpanel = "p-tabs-panel"
+}
+declare class TabsStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-tabs-scrollable': any;
+        })[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TabsStyle>;
+}
+interface TabsStyle extends BaseStyle {
+}
+
+/**
+ * Tabs facilitates seamless switching between different views.
+ * @group Components
+ */
+declare class Tabs extends BaseComponent<TabsPassThrough> {
+    componentName: string;
+    $pcTabs: Tabs | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Value of the active tab.
+     * @defaultValue undefined
+     * @group Props
+     */
+    value: _angular_core.ModelSignal<string | number | undefined>;
+    /**
+     * When specified, enables horizontal and/or vertical scrolling.
+     * @type boolean
+     * @defaultValue false
+     * @group Props
+     */
+    scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When enabled, tabs are not rendered until activation.
+     * @type boolean
+     * @defaultValue false
+     * @group Props
+     */
+    lazy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When enabled, the focused tab is activated.
+     * @type boolean
+     * @defaultValue false
+     * @group Props
+     */
+    selectOnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to display navigation buttons in container when scrollable is enabled.
+     * @type boolean
+     * @defaultValue true
+     * @group Props
+     */
+    showNavigators: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Tabindex of the tab buttons.
+     * @type number
+     * @defaultValue 0
+     * @group Props
+     */
+    tabindex: _angular_core.InputSignalWithTransform<number, unknown>;
+    id: _angular_core.WritableSignal<string>;
+    _componentStyle: TabsStyle;
+    updateValue(newValue: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tabs, "p-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "showNavigators": { "alias": "showNavigators"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TabPanelsStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanelsStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TabPanelsStyle>;
+}
+interface TabPanelsStyle extends BaseStyle {
+}
+
+/**
+ * TabPanels is a helper component for Tabs component.
+ * @group Components
+ */
+declare class TabPanels extends BaseComponent<TabPanelsPassThrough> {
+    componentName: string;
+    $pcTabPanels: TabPanels | undefined;
+    bindDirectiveInstance: Bind;
+    _componentStyle: TabPanelsStyle;
+    onAfterViewChecked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanels, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabPanels, "p-tabpanels", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TabPanelStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-tabpanel-active': any;
+        })[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanelStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TabPanelStyle>;
+}
+interface TabPanelStyle extends BaseStyle {
+}
+
+/**
+ * TabPanel is a helper component for Tabs component.
+ * @group Components
+ */
+declare class TabPanel extends BaseComponent<TabPanelPassThrough> {
+    componentName: string;
+    $pcTabPanel: TabPanel | undefined;
+    bindDirectiveInstance: Bind;
+    pcTabs: Tabs;
+    onAfterViewChecked(): void;
+    /**
+     * When enabled, tab is not rendered until activation.
+     * @type boolean
+     * @defaultValue false
+     * @group Props
+     */
+    lazy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Value of the active tab.
+     * @defaultValue undefined
+     * @group Props
+     */
+    value: _angular_core.ModelSignal<string | number | undefined>;
+    /**
+     * Template for initializing complex content when lazy is enabled.
+     * @group Templates
+     */
+    content: _angular_core.Signal<unknown>;
+    id: _angular_core.Signal<string>;
+    ariaLabelledby: _angular_core.Signal<string>;
+    active: _angular_core.Signal<boolean>;
+    isLazyEnabled: _angular_core.Signal<boolean>;
+    private hasBeenRendered;
+    shouldRender: _angular_core.Signal<boolean>;
+    _componentStyle: TabPanelStyle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabPanel, "p-tabpanel", never, { "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["content"], ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TabListStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: string;
+        content: string;
+        tabList: string;
+        activeBar: string;
+        prevButton: string;
+        nextButton: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabListStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TabListStyle>;
+}
+interface TabListStyle extends BaseStyle {
+}
+
+/**
+ * TabList is a helper component for Tabs component.
+ * @group Components
+ */
+declare class TabList extends BaseComponent<TabListPassThrough> {
+    componentName: string;
+    $pcTabList: TabList | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * A template reference variable that represents the previous icon in a UI component.
+     * @type {TemplateRef<any> | undefined}
+     * @group Templates
+     */
+    prevIconTemplate: TemplateRef<any> | undefined;
+    /**
+     * A template reference variable that represents the next icon in a UI component.
+     * @type {TemplateRef<any> | undefined}
+     * @group Templates
+     */
+    nextIconTemplate: TemplateRef<any> | undefined;
+    templates: QueryList<PrimeTemplate> | undefined;
+    content: ElementRef<HTMLDivElement>;
+    prevButton: ElementRef<HTMLButtonElement>;
+    nextButton: ElementRef<HTMLButtonElement>;
+    inkbar: ElementRef<HTMLSpanElement>;
+    tabs: ElementRef<HTMLDivElement>;
+    pcTabs: any;
+    isPrevButtonEnabled: _angular_core.WritableSignal<boolean>;
+    isNextButtonEnabled: _angular_core.WritableSignal<boolean>;
+    resizeObserver: ResizeObserver;
+    showNavigators: _angular_core.Signal<any>;
+    tabindex: _angular_core.Signal<any>;
+    scrollable: _angular_core.Signal<any>;
+    _componentStyle: TabListStyle;
+    constructor();
+    get prevButtonAriaLabel(): string | undefined;
+    get nextButtonAriaLabel(): string | undefined;
+    onAfterViewInit(): void;
+    _prevIconTemplate: TemplateRef<any> | undefined;
+    _nextIconTemplate: TemplateRef<any> | undefined;
+    onAfterContentInit(): void;
+    onDestroy(): void;
+    onScroll(event: Event): void;
+    onPrevButtonClick(): void;
+    onNextButtonClick(): void;
+    updateButtonState(): void;
+    updateInkBar(): void;
+    getVisibleButtonWidths(): number;
+    bindResizeObserver(): void;
+    unbindResizeObserver(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabList, "p-tablist", never, {}, {}, ["prevIconTemplate", "nextIconTemplate", "templates"], ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TabStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-tab-active': any;
+            'p-disabled': any;
+        })[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TabStyle>;
+}
+interface TabStyle extends BaseStyle {
+}
+
+/**
+ * Defines valid properties in Tab component.
+ * @group Components
+ */
+declare class Tab extends BaseComponent<TabPassThrough> {
+    componentName: string;
+    $pcTab: Tab | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Value of tab.
+     * @defaultValue undefined
+     * @group Props
+     */
+    value: _angular_core.ModelSignal<string | number | undefined>;
+    /**
+     * Whether the tab is disabled.
+     * @defaultValue false
+     * @group Props
+     */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    pcTabs: any;
+    pcTabList: any;
+    el: ElementRef<any>;
+    _componentStyle: TabStyle;
+    ripple: _angular_core.Signal<boolean>;
+    id: _angular_core.Signal<string>;
+    ariaControls: _angular_core.Signal<string>;
+    active: _angular_core.Signal<boolean>;
+    tabindex: _angular_core.Signal<any>;
+    mutationObserver: MutationObserver | undefined;
+    onFocus(event: FocusEvent): void;
+    onClick(event: MouseEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onAfterViewInit(): void;
+    onArrowRightKey(event: any): void;
+    onArrowLeftKey(event: any): void;
+    onHomeKey(event: any): void;
+    onEndKey(event: any): void;
+    onPageDownKey(event: any): void;
+    onPageUpKey(event: any): void;
+    onEnterKey(event: any): void;
+    findNextTab(tabElement: any, selfCheck?: boolean): any;
+    findPrevTab(tabElement: any, selfCheck?: boolean): any;
+    findFirstTab(): any;
+    findLastTab(): any;
+    changeActiveValue(): void;
+    changeFocusedTab(event: any, element: any): void;
+    scrollInView(element: any): void;
+    bindMutationObserver(): void;
+    unbindMutationObserver(): void;
+    onDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tab, "p-tab", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, [{ directive: typeof i1$1.Ripple; inputs: {}; outputs: {}; }, { directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TabsModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TabsModule, never, [typeof Tabs, typeof TabPanels, typeof TabPanel, typeof TabList, typeof Tab, typeof i1.BindModule], [typeof Tabs, typeof TabPanels, typeof TabPanel, typeof TabList, typeof Tab, typeof i1.BindModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TabsModule>;
+}
+
+export { Tab, TabList, TabPanel, TabPanels, Tabs, TabsClasses, TabsModule, TabsStyle };

package/types/primeng-tag.d.ts

@@ -0,0 +1,115 @@
+import { TagPassThrough } from 'primeng/types/tag';
+export * from 'primeng/types/tag';
+import * as i0 from '@angular/core';
+import { AfterContentInit, TemplateRef, QueryList } from '@angular/core';
+import * as i2 from 'primeng/api';
+import { PrimeTemplate } from 'primeng/api';
+import { BaseComponent } from 'primeng/basecomponent';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primeng/base';
+
+/**
+ *
+ * Tag component is used to categorize content.
+ *
+ * [Live Demo](https://www.primeng.org/tag)
+ *
+ * @module tagstyle
+ *
+ */
+declare enum TagClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-tag",
+    /**
+     * Class name of the icon element
+     */
+    icon = "p-tag-icon",
+    /**
+     * Class name of the label element
+     */
+    label = "p-tag-label"
+}
+declare class TagStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-tag-info': boolean;
+            'p-tag-success': boolean;
+            'p-tag-warn': boolean;
+            'p-tag-danger': boolean;
+            'p-tag-secondary': boolean;
+            'p-tag-contrast': boolean;
+            'p-tag-rounded': any;
+        })[];
+        icon: string;
+        label: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TagStyle>;
+}
+interface TagStyle extends BaseStyle {
+}
+
+/**
+ * Tag component is used to categorize content.
+ * @group Components
+ */
+declare class Tag extends BaseComponent<TagPassThrough> implements AfterContentInit {
+    componentName: string;
+    $pcTag: Tag | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Style class of the component.
+     * @deprecated since v20.0.0, use `class` instead.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Severity type of the tag.
+     * @group Props
+     */
+    severity: 'success' | 'secondary' | 'info' | 'warn' | 'danger' | 'contrast' | undefined | null;
+    /**
+     * Value to display inside the tag.
+     * @group Props
+     */
+    value: string | undefined;
+    /**
+     * Icon of the tag to display next to the value.
+     * @group Props
+     */
+    icon: string | undefined;
+    /**
+     * Whether the corners of the tag are rounded.
+     * @group Props
+     */
+    rounded: boolean | undefined;
+    /**
+     * Custom icon template.
+     * @group Templates
+     */
+    iconTemplate: TemplateRef<void> | undefined;
+    templates: QueryList<PrimeTemplate> | undefined;
+    _iconTemplate: TemplateRef<void> | undefined;
+    _componentStyle: TagStyle;
+    onAfterContentInit(): void;
+    get dataP(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Tag, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Tag, "p-tag", never, { "styleClass": { "alias": "styleClass"; "required": false; }; "severity": { "alias": "severity"; "required": false; }; "value": { "alias": "value"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; }, {}, ["iconTemplate", "templates"], ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_rounded: unknown;
+}
+declare class TagModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TagModule, never, [typeof Tag, typeof i2.SharedModule], [typeof Tag, typeof i2.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TagModule>;
+}
+
+export { Tag, TagClasses, TagModule, TagStyle };

package/types/primeng-terminal.d.ts

@@ -0,0 +1,141 @@
+import { TerminalPassThrough } from 'primeng/types/terminal';
+export * from 'primeng/types/terminal';
+import * as i0 from '@angular/core';
+import { AfterViewInit, AfterViewChecked, OnDestroy, ElementRef } from '@angular/core';
+import { BaseComponent } from 'primeng/basecomponent';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import * as rxjs from 'rxjs';
+import { Subscription } from 'rxjs';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primeng/base';
+import * as i2 from 'primeng/api';
+
+/**
+ *
+ * Terminal is a text based user interface.
+ *
+ * [Live Demo](https://www.primeng.org/terminal)
+ *
+ * @module terminalstyle
+ *
+ */
+declare enum TerminalClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-terminal",
+    /**
+     * Class name of the welcome message element
+     */
+    welcomeMessage = "p-terminal-welcome-message",
+    /**
+     * Class name of the command list element
+     */
+    commandList = "p-terminal-command-list",
+    /**
+     * Class name of the command element
+     */
+    command = "p-terminal-command",
+    /**
+     * Class name of the command value element
+     */
+    commandValue = "p-terminal-command-value",
+    /**
+     * Class name of the command response element
+     */
+    commandResponse = "p-terminal-command-response",
+    /**
+     * Class name of the prompt element
+     */
+    prompt = "p-terminal-prompt",
+    /**
+     * Class name of the prompt label element
+     */
+    promptLabel = "p-terminal-prompt-label",
+    /**
+     * Class name of the prompt value element
+     */
+    promptValue = "p-terminal-prompt-value"
+}
+declare class TerminalStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: () => string[];
+        welcomeMessage: string;
+        commandList: string;
+        command: string;
+        commandValue: string;
+        commandResponse: string;
+        prompt: string;
+        promptLabel: string;
+        promptValue: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminalStyle>;
+}
+interface TerminalStyle extends BaseStyle {
+}
+
+declare class TerminalService {
+    private commandSource;
+    private responseSource;
+    commandHandler: rxjs.Observable<string>;
+    responseHandler: rxjs.Observable<string>;
+    sendCommand(command: string): void;
+    sendResponse(response: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminalService>;
+}
+
+/**
+ * Terminal is a text based user interface.
+ * @group Components
+ */
+declare class Terminal extends BaseComponent<TerminalPassThrough> implements AfterViewInit, AfterViewChecked, OnDestroy {
+    terminalService: TerminalService;
+    componentName: string;
+    $pcTerminal: Terminal | undefined;
+    bindDirectiveInstance: Bind;
+    /**
+     * Initial text to display on terminal.
+     * @group Props
+     */
+    welcomeMessage: string | undefined;
+    /**
+     * Prompt text for each command.
+     * @group Props
+     */
+    prompt: string | undefined;
+    /**
+     * Style class of the component.
+     * @deprecated since v20.0.0, use `class` instead.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    commands: any[];
+    command: string;
+    container: Element;
+    commandProcessed: boolean;
+    subscription: Subscription;
+    _componentStyle: TerminalStyle;
+    inputRef: ElementRef<HTMLInputElement>;
+    onHostClick(): void;
+    constructor(terminalService: TerminalService);
+    onAfterViewInit(): void;
+    onAfterViewChecked(): void;
+    set response(value: string);
+    handleCommand(event: KeyboardEvent): void;
+    focus(element: HTMLElement): void;
+    onDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Terminal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Terminal, "p-terminal", never, { "welcomeMessage": { "alias": "welcomeMessage"; "required": false; }; "prompt": { "alias": "prompt"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "response": { "alias": "response"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class TerminalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TerminalModule, never, [typeof Terminal, typeof i2.SharedModule], [typeof Terminal, typeof i2.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TerminalModule>;
+}
+
+export { Terminal, TerminalClasses, TerminalModule, TerminalService, TerminalStyle };