@ops-prime/primeng 0.0.0-stage → 21.1.11

package/types/primeng-inputtext.d.ts

@@ -0,0 +1,117 @@
+import * as _angular_core from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { BaseModelHolder } from 'primeng/basemodelholder';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import { Fluid } from 'primeng/fluid';
+import { InputTextPassThrough } from 'primeng/types/inputtext';
+import { BaseStyle } from 'primeng/base';
+
+/**
+ *
+ * InputText renders a text field to enter data.
+ *
+ * [Live Demo](https://www.primeng.org/inputtext/)
+ *
+ * @module inputtextstyle
+ *
+ */
+declare enum InputTextClasses {
+    /**
+     * The class of root element
+     */
+    root = "p-inputtext"
+}
+declare class InputTextStyle extends BaseStyle {
+    name: string;
+    style: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-filled': any;
+            'p-inputtext-sm': boolean;
+            'p-inputtext-lg': boolean;
+            'p-invalid': any;
+            'p-variant-filled': boolean;
+            'p-inputtext-fluid': any;
+        })[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTextStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InputTextStyle>;
+}
+interface InputTextStyle extends BaseStyle {
+}
+
+/**
+ * InputText directive is an extension to standard input element with theming.
+ * @group Components
+ */
+declare class InputText extends BaseModelHolder<InputTextPassThrough> {
+    componentName: string;
+    hostName: any;
+    /**
+     * Used to pass attributes to DOM elements inside the InputText component.
+     * @defaultValue undefined
+     * @deprecated use pInputTextPT instead.
+     * @group Props
+     */
+    ptInputText: _angular_core.InputSignal<InputTextPassThrough>;
+    /**
+     * Used to pass attributes to DOM elements inside the InputText component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    pInputTextPT: _angular_core.InputSignal<InputTextPassThrough>;
+    /**
+     * Indicates whether the component should be rendered without styles.
+     * @defaultValue undefined
+     * @group Props
+     */
+    pInputTextUnstyled: _angular_core.InputSignal<boolean | undefined>;
+    bindDirectiveInstance: Bind;
+    $pcInputText: InputText | undefined;
+    ngControl: NgControl | null;
+    pcFluid: Fluid | null;
+    /**
+     * Defines the size of the component.
+     * @group Props
+     */
+    pSize: 'large' | 'small' | undefined;
+    /**
+     * Specifies the input variant of the component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    variant: _angular_core.InputSignal<"filled" | "outlined" | undefined>;
+    /**
+     * Spans 100% width of the container when enabled.
+     * @defaultValue undefined
+     * @group Props
+     */
+    fluid: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * When present, it specifies that the component should have invalid state style.
+     * @defaultValue false
+     * @group Props
+     */
+    invalid: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    $variant: _angular_core.Signal<"filled" | "outlined" | null>;
+    _componentStyle: InputTextStyle;
+    constructor();
+    onAfterViewInit(): void;
+    onAfterViewChecked(): void;
+    onDoCheck(): void;
+    onInput(): void;
+    get hasFluid(): boolean;
+    get dataP(): string | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputText, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputText, "[pInputText]", never, { "hostName": { "alias": "hostName"; "required": false; }; "ptInputText": { "alias": "ptInputText"; "required": false; "isSignal": true; }; "pInputTextPT": { "alias": "pInputTextPT"; "required": false; "isSignal": true; }; "pInputTextUnstyled": { "alias": "pInputTextUnstyled"; "required": false; "isSignal": true; }; "pSize": { "alias": "pSize"; "required": false; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class InputTextModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTextModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<InputTextModule, never, [typeof InputText], [typeof InputText]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<InputTextModule>;
+}
+
+export { InputText, InputTextClasses, InputTextModule, InputTextStyle };

package/types/primeng-keyfilter.d.ts

@@ -0,0 +1,61 @@
+import * as i0 from '@angular/core';
+import { Provider, ElementRef, EventEmitter } from '@angular/core';
+import { Validator, AbstractControl } from '@angular/forms';
+
+type KeyFilterPattern = 'pint' | 'int' | 'pnum' | 'money' | 'num' | 'hex' | 'email' | 'alpha' | 'alphanum';
+declare const KEYFILTER_VALIDATOR: Provider;
+/**
+ * KeyFilter Directive is a built-in feature of InputText to restrict user input based on a regular expression.
+ * @group Components
+ */
+declare class KeyFilter implements Validator {
+    private document;
+    private platformId;
+    el: ElementRef;
+    /**
+     * When enabled, instead of blocking keys, input is validated internally to test against the regular expression.
+     * @group Props
+     */
+    pValidateOnly: boolean | undefined;
+    /**
+     * Sets the pattern for key filtering.
+     * @group Props
+     */
+    set pattern(_pattern: RegExp | KeyFilterPattern | null | undefined);
+    get pattern(): RegExp | KeyFilterPattern | null | undefined;
+    /**
+     * Emits a value whenever the ngModel of the component changes.
+     * @param {(string | number)} modelValue - Custom model change event.
+     * @group Emits
+     */
+    ngModelChange: EventEmitter<string | number>;
+    regex: RegExp;
+    _pattern: RegExp | KeyFilterPattern | null | undefined;
+    isAndroid: boolean;
+    lastValue: any;
+    constructor(document: Document, platformId: any, el: ElementRef);
+    isNavKeyPress(e: KeyboardEvent): boolean;
+    isSpecialKey(e: KeyboardEvent): boolean | "" | undefined;
+    getKey(e: KeyboardEvent): any;
+    getCharCode(e: KeyboardEvent): number;
+    findDelta(value: string, prevValue: string): string;
+    isValidChar(c: string): boolean;
+    isValidString(str: string): boolean;
+    onInput(e: KeyboardEvent): void;
+    onKeyPress(e: KeyboardEvent): void;
+    onPaste(e: ClipboardEvent): void;
+    validate(_c: AbstractControl): {
+        [key: string]: any;
+    } | any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyFilter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeyFilter, "[pKeyFilter]", never, { "pValidateOnly": { "alias": "pValidateOnly"; "required": false; }; "pattern": { "alias": "pKeyFilter"; "required": false; }; }, { "ngModelChange": "ngModelChange"; }, never, never, true, never>;
+    static ngAcceptInputType_pValidateOnly: unknown;
+}
+declare class KeyFilterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyFilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KeyFilterModule, never, [typeof KeyFilter], [typeof KeyFilter]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KeyFilterModule>;
+}
+
+export { KEYFILTER_VALIDATOR, KeyFilter, KeyFilterModule };
+export type { KeyFilterPattern };

package/types/primeng-knob.d.ts

@@ -0,0 +1,213 @@
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BaseEditableHolder } from 'primeng/baseeditableholder';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import { VoidListener } from 'primeng/ts-helpers';
+import { KnobPassThrough } from 'primeng/types/knob';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primeng/base';
+import * as i2 from 'primeng/api';
+
+/**
+ *
+ * Knob is a form component to define number inputs with a dial.
+ *
+ * [Live Demo](https://www.primeng.org/knob/)
+ *
+ * @module knobstyle
+ *
+ */
+declare enum KnobClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-knob",
+    /**
+     * Class name of the range element
+     */
+    range = "p-knob-range",
+    /**
+     * Class name of the value element
+     */
+    value = "p-knob-value",
+    /**
+     * Class name of the text element
+     */
+    text = "p-knob-text"
+}
+declare class KnobStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-disabled': any;
+        })[];
+        range: string;
+        value: string;
+        text: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<KnobStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KnobStyle>;
+}
+interface KnobStyle extends BaseStyle {
+}
+
+declare const KNOB_VALUE_ACCESSOR: any;
+/**
+ * Knob is a form component to define number inputs with a dial.
+ * @group Components
+ */
+declare class Knob extends BaseEditableHolder<KnobPassThrough> {
+    componentName: string;
+    $pcKnob: Knob | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Style class of the component.
+     * @deprecated since v20.0.0, use `class` instead.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Defines a string that labels the input for accessibility.
+     * @group Props
+     */
+    ariaLabel: string | undefined;
+    /**
+     * Specifies one or more IDs in the DOM that labels the input field.
+     * @group Props
+     */
+    ariaLabelledBy: string | undefined;
+    /**
+     * Index of the element in tabbing order.
+     * @group Props
+     */
+    tabindex: number;
+    /**
+     * Background of the value.
+     * @group Props
+     */
+    valueColor: string;
+    /**
+     * Background color of the range.
+     * @group Props
+     */
+    rangeColor: string;
+    /**
+     * Color of the value text.
+     * @group Props
+     */
+    textColor: string;
+    /**
+     * Template string of the value.
+     * @group Props
+     */
+    valueTemplate: string;
+    /**
+     * Size of the component in pixels.
+     * @group Props
+     */
+    size: number;
+    /**
+     * Mininum boundary value.
+     * @group Props
+     */
+    min: number;
+    /**
+     * Maximum boundary value.
+     * @group Props
+     */
+    max: number;
+    /**
+     * Step factor to increment/decrement the value.
+     * @group Props
+     */
+    step: number;
+    /**
+     * Width of the knob stroke.
+     * @group Props
+     */
+    strokeWidth: number;
+    /**
+     * Whether the show the value inside the knob.
+     * @group Props
+     */
+    showValue: boolean;
+    /**
+     * When present, it specifies that the component value cannot be edited.
+     * @group Props
+     */
+    readonly: boolean;
+    /**
+     * Callback to invoke on value change.
+     * @param {number} value - New value.
+     * @group Emits
+     */
+    onChange: EventEmitter<number>;
+    radius: number;
+    midX: number;
+    midY: number;
+    minRadians: number;
+    maxRadians: number;
+    value: i0.WritableSignal<number>;
+    windowMouseMoveListener: VoidListener;
+    windowMouseUpListener: VoidListener;
+    windowTouchMoveListener: VoidListener;
+    windowTouchEndListener: VoidListener;
+    _componentStyle: KnobStyle;
+    mapRange(x: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+    onClick(event: MouseEvent): void;
+    updateValue(offsetX: number, offsetY: number): void;
+    updateModel(angle: number, start: number): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchEnd(event: TouchEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onTouchMove(event: Event): void;
+    updateModelValue(newValue: any): void;
+    onKeyDown(event: KeyboardEvent): void;
+    rangePath(): string;
+    valuePath(): string;
+    zeroRadians(): number;
+    valueRadians(): number;
+    minX(): number;
+    minY(): number;
+    maxX(): number;
+    maxY(): number;
+    zeroX(): number;
+    zeroY(): number;
+    valueX(): number;
+    valueY(): number;
+    largeArc(): 0 | 1;
+    sweep(): 0 | 1;
+    valueToDisplay(): string;
+    get _value(): number;
+    /**
+     * @override
+     *
+     * @see {@link BaseEditableHolder.writeControlValue}
+     * Writes the value to the control.
+     */
+    writeControlValue(value: any, setModelValue: (value: any) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Knob, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Knob, "p-knob", never, { "styleClass": { "alias": "styleClass"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "valueColor": { "alias": "valueColor"; "required": false; }; "rangeColor": { "alias": "rangeColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "valueTemplate": { "alias": "valueTemplate"; "required": false; }; "size": { "alias": "size"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "onChange": "onChange"; }, never, never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_tabindex: unknown;
+    static ngAcceptInputType_size: unknown;
+    static ngAcceptInputType_min: unknown;
+    static ngAcceptInputType_max: unknown;
+    static ngAcceptInputType_step: unknown;
+    static ngAcceptInputType_strokeWidth: unknown;
+    static ngAcceptInputType_showValue: unknown;
+    static ngAcceptInputType_readonly: unknown;
+}
+declare class KnobModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KnobModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KnobModule, never, [typeof Knob, typeof i2.SharedModule], [typeof Knob, typeof i2.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KnobModule>;
+}
+
+export { KNOB_VALUE_ACCESSOR, Knob, KnobClasses, KnobModule, KnobStyle };