@nxgt/material-vue 0.1.0

package/dist/lib/lib/components/ui/extended-label/index.d.ts

@@ -0,0 +1,2 @@
+export type { ExtendedLabelProps } from './extended-label.vue';
+export { default as ExtendedLabel } from './extended-label.vue';

package/dist/lib/lib/components/ui/feedback/circular-progress.vue.d.ts

@@ -0,0 +1,28 @@
+import { VariantProps } from 'class-variance-authority';
+import { HTMLAttributes } from 'vue';
+declare const variants: (props?: ({
+    variant?: "default" | "info" | "warning" | "primary" | "secondary" | "success" | "error" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type CircularProgressProps = {
+    value: number;
+    renderLabel?: (progress: number) => number | string;
+    size?: number;
+    strokeWidth?: number;
+    circleStrokeWidth?: number;
+    progressStrokeWidth?: number;
+    shape?: 'square' | 'round';
+    class?: HTMLAttributes['class'];
+    progressClass?: HTMLAttributes['class'];
+    labelClass?: HTMLAttributes['class'];
+    showLabel?: boolean;
+    variant?: VariantProps<typeof variants>['variant'];
+};
+declare const __VLS_export: import('vue').DefineComponent<CircularProgressProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CircularProgressProps> & Readonly<{}>, {
+    size: number;
+    variant: "default" | "info" | "warning" | "primary" | "secondary" | "success" | "error" | null;
+    circleStrokeWidth: number;
+    progressStrokeWidth: number;
+    shape: "square" | "round";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/feedback/index.d.ts

@@ -0,0 +1,5 @@
+export type { CircularProgressProps } from './circular-progress.vue';
+export { default as CircularProgress } from './circular-progress.vue';
+export { type SpinnerVariants, spinnerVariants } from './spinner.variants';
+export type { SpinnerProps } from './spinner.vue';
+export { default as Spinner } from './spinner.vue';

package/dist/lib/lib/components/ui/feedback/spinner.compound-variants.d.ts

@@ -0,0 +1,125 @@
+export declare const spinnerCompoundVariants: ({
+    variant: "1";
+    color: "primary";
+    class: string;
+} | {
+    variant: "1";
+    color: "secondary";
+    class: string;
+} | {
+    variant: "1";
+    color: "success";
+    class: string;
+} | {
+    variant: "1";
+    color: "info";
+    class: string;
+} | {
+    variant: "1";
+    color: "warning";
+    class: string;
+} | {
+    variant: "1";
+    color: "error";
+    class: string;
+} | {
+    variant: "1";
+    color: "default";
+    class: string;
+} | {
+    variant: "2";
+    color: "primary";
+    class: string;
+} | {
+    variant: "2";
+    color: "secondary";
+    class: string;
+} | {
+    variant: "2";
+    color: "success";
+    class: string;
+} | {
+    variant: "2";
+    color: "info";
+    class: string;
+} | {
+    variant: "2";
+    color: "warning";
+    class: string;
+} | {
+    variant: "2";
+    color: "error";
+    class: string;
+} | {
+    variant: "2";
+    color: "default";
+    class: string;
+} | {
+    variant: "2";
+    color: "light";
+    class: string;
+} | {
+    variant: "3";
+    color: "primary";
+    class: string;
+} | {
+    variant: "3";
+    color: "secondary";
+    class: string;
+} | {
+    variant: "3";
+    color: "success";
+    class: string;
+} | {
+    variant: "3";
+    color: "info";
+    class: string;
+} | {
+    variant: "3";
+    color: "warning";
+    class: string;
+} | {
+    variant: "3";
+    color: "error";
+    class: string;
+} | {
+    variant: "3";
+    color: "default";
+    class: string;
+} | {
+    variant: "3";
+    color: "light";
+    class: string;
+} | {
+    variant: "4";
+    color: "primary";
+    class: string;
+} | {
+    variant: "4";
+    color: "secondary";
+    class: string;
+} | {
+    variant: "4";
+    color: "success";
+    class: string;
+} | {
+    variant: "4";
+    color: "info";
+    class: string;
+} | {
+    variant: "4";
+    color: "warning";
+    class: string;
+} | {
+    variant: "4";
+    color: "error";
+    class: string;
+} | {
+    variant: "4";
+    color: "default";
+    class: string;
+} | {
+    variant: "4";
+    color: "light";
+    class: string;
+})[];

package/dist/lib/lib/components/ui/feedback/spinner.variants.d.ts

@@ -0,0 +1,6 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const spinnerVariants: (props?: ({
+    variant?: "1" | "2" | "3" | "4" | null | undefined;
+    color?: "default" | "info" | "warning" | "light" | "primary" | "secondary" | "success" | "error" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type SpinnerVariants = VariantProps<typeof spinnerVariants>;

package/dist/lib/lib/components/ui/feedback/spinner.vue.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes } from 'vue';
+import { SpinnerVariants } from './spinner.variants';
+export type SpinnerProps = {
+    variant?: SpinnerVariants['variant'];
+    color?: SpinnerVariants['color'];
+    class?: HTMLAttributes['class'];
+};
+declare const __VLS_export: import('vue').DefineComponent<SpinnerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SpinnerProps> & Readonly<{}>, {
+    color: "default" | "info" | "warning" | "light" | "primary" | "secondary" | "success" | "error" | null;
+    variant: "1" | "2" | "3" | "4" | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/field/field.vue.d.ts

@@ -0,0 +1,7 @@
+import { FieldConfig } from './types';
+export type FieldProps = {
+    config: FieldConfig;
+};
+declare const __VLS_export: import('vue').DefineComponent<FieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/field/index.d.ts

@@ -0,0 +1,4 @@
+export type { FieldProps } from './field.vue';
+export { default as Field } from './field.vue';
+export { resolveField } from './resolve-field';
+export type { FieldConfig, FieldType } from './types';

package/dist/lib/lib/components/ui/field/resolve-field.d.ts

@@ -0,0 +1,7 @@
+import { Component } from 'vue';
+import { FieldConfig } from './types';
+export type ResolvedField = {
+    component: Component;
+    props: Record<string, unknown>;
+};
+export declare function resolveField(config: FieldConfig): ResolvedField;

package/dist/lib/lib/components/ui/field/types.d.ts

@@ -0,0 +1,68 @@
+import { AutocompleteProps } from '../autocomplete';
+import { CheckCardFieldProps } from '../check-card-field';
+import { CheckboxGroupProps } from '../checkbox-group';
+import { CodeEditorProps } from '../code';
+import { DateFieldProps } from '../date-field';
+import { DateRangeFieldProps } from '../date-range-field';
+import { ImageFieldProps } from '../image-field';
+import { NumberFieldProps } from '../number-field';
+import { OtpFieldProps } from '../otp-field';
+import { RadioGroupFieldProps } from '../radio-group-field';
+import { RichTextEditorProps } from '../rich-text-editor';
+import { SelectCardFieldProps } from '../select-card-field';
+import { SelectChipFieldProps } from '../select-chip-field';
+import { SliderFieldProps } from '../slider-field';
+import { SwitchFieldProps } from '../switch-field';
+import { TextFieldProps } from '../text-field';
+import { TextareaFieldProps } from '../textarea-field';
+import { TimeFieldProps } from '../time-field';
+import { NetworkUploadFieldProps } from '../upload/network-upload-field';
+import { UploadFieldProps } from '../upload-field';
+export type FieldType = 'text' | 'number' | 'textarea' | 'select' | 'multi-select' | 'chips-single' | 'chips-multiple' | 'radio-group' | 'checkbox-group' | 'switch' | 'date' | 'date-range' | 'slider' | 'time' | 'location' | 'image' | 'upload' | 'network-upload' | 'otp' | 'autocomplete' | 'rich-text-editor' | 'code-editor' | 'check-card' | 'select-card';
+export type FieldConfig = ({
+    type: 'text';
+} & Omit<TextFieldProps, 'type'>) | ({
+    type: 'number';
+} & NumberFieldProps) | ({
+    type: 'textarea';
+} & TextareaFieldProps) | ({
+    type: 'select';
+} & AutocompleteProps) | ({
+    type: 'multi-select';
+} & AutocompleteProps) | ({
+    type: 'chips-single';
+} & SelectChipFieldProps) | ({
+    type: 'chips-multiple';
+} & SelectChipFieldProps) | ({
+    type: 'radio-group';
+} & RadioGroupFieldProps) | ({
+    type: 'checkbox-group';
+} & CheckboxGroupProps) | ({
+    type: 'switch';
+} & SwitchFieldProps) | ({
+    type: 'date';
+} & DateFieldProps) | ({
+    type: 'date-range';
+} & DateRangeFieldProps) | ({
+    type: 'slider';
+} & SliderFieldProps) | ({
+    type: 'time';
+} & TimeFieldProps) | ({
+    type: 'image';
+} & ImageFieldProps) | ({
+    type: 'upload';
+} & UploadFieldProps) | ({
+    type: 'network-upload';
+} & NetworkUploadFieldProps) | ({
+    type: 'otp';
+} & OtpFieldProps) | ({
+    type: 'autocomplete';
+} & AutocompleteProps) | ({
+    type: 'rich-text-editor';
+} & RichTextEditorProps) | ({
+    type: 'code-editor';
+} & CodeEditorProps) | ({
+    type: 'check-card';
+} & CheckCardFieldProps) | ({
+    type: 'select-card';
+} & SelectCardFieldProps);

package/dist/lib/lib/components/ui/file-list/file-list-field.vue.d.ts

@@ -0,0 +1,18 @@
+import { FileListFieldProps } from './types';
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<FileListFieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<FileListFieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/lib/lib/components/ui/file-list/file-list-s3-field.vue.d.ts

@@ -0,0 +1,8 @@
+import { FileListS3FieldProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<FileListS3FieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<FileListS3FieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/file-list/file-list.vue.d.ts

@@ -0,0 +1,29 @@
+import { HTMLAttributes } from 'vue';
+import { FileListItem } from './types';
+export type FileListProps = {
+    items: FileListItem[];
+    onRemove?: (item: FileListItem) => void;
+    empty?: string;
+    loading?: boolean;
+    class?: HTMLAttributes['class'];
+    'aria-label'?: string;
+};
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<FileListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: (item: FileListItem) => any;
+}, string, import('vue').PublicProps, Readonly<FileListProps> & Readonly<{
+    onRemove?: ((item: FileListItem) => any) | undefined;
+}>, {
+    loading: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/lib/lib/components/ui/file-list/format-file-size.d.ts

@@ -0,0 +1 @@
+export declare function formatFileSize(bytes: number): string;

package/dist/lib/lib/components/ui/file-list/index.d.ts

@@ -0,0 +1,6 @@
+export type { FileListProps } from './file-list.vue';
+export { default as FileList } from './file-list.vue';
+export { default as FileListField } from './file-list-field.vue';
+export { default as FileListS3Field } from './file-list-s3-field.vue';
+export { formatFileSize } from './format-file-size';
+export type { FileListFieldProps, FileListItem, FileListS3FieldProps, } from './types';

package/dist/lib/lib/components/ui/file-list/partials/file-list-dropzone.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    disabled?: boolean;
+    error?: boolean;
+    active?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/file-list/partials/file-list-field-row.vue.d.ts

@@ -0,0 +1,17 @@
+import { NetworkUploadDisplayItem } from '../../upload/network-upload-field';
+export type FileListFieldRowProps = {
+    item: NetworkUploadDisplayItem;
+    accept?: string;
+    disabled?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<FileListFieldRowProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: (item: NetworkUploadDisplayItem) => any;
+    replace: (item: NetworkUploadDisplayItem, file: File) => any;
+    retry: (item: NetworkUploadDisplayItem) => any;
+}, string, import('vue').PublicProps, Readonly<FileListFieldRowProps> & Readonly<{
+    onRemove?: ((item: NetworkUploadDisplayItem) => any) | undefined;
+    onReplace?: ((item: NetworkUploadDisplayItem, file: File) => any) | undefined;
+    onRetry?: ((item: NetworkUploadDisplayItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/file-list/partials/file-list-row.vue.d.ts

@@ -0,0 +1,12 @@
+import { FileListItem } from '../types';
+type __VLS_Props = {
+    item: FileListItem;
+    removable?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: (item: FileListItem) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRemove?: ((item: FileListItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/file-list/types.d.ts

@@ -0,0 +1,46 @@
+import { HTMLAttributes } from 'vue';
+import { PresignedUploadTarget } from '../upload/s3-upload-field';
+export type FileListItem = {
+    id: string;
+    name: string;
+    size?: number;
+    href?: string;
+    type?: string;
+    disabled?: boolean;
+};
+export type FileListFieldProps = {
+    label?: string;
+    helperText?: string;
+    error?: boolean;
+    disabled?: boolean;
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    onUpload: (file: File, onProgress?: (percent: number) => void) => Promise<string>;
+    onRemove?: (value: string) => void | Promise<void>;
+    onError?: (file: File, error: unknown) => void;
+    resolveUrl?: (value: string) => string | null | undefined;
+    name?: string;
+    modelValue?: string[];
+    required?: boolean;
+    empty?: string;
+    class?: HTMLAttributes['class'];
+};
+export type FileListS3FieldProps = {
+    label?: string;
+    helperText?: string;
+    error?: boolean;
+    disabled?: boolean;
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    onRemove?: (value: string) => void | Promise<void>;
+    onError?: (file: File, error: unknown) => void;
+    resolveUrl?: (value: string) => string | null | undefined;
+    name?: string;
+    modelValue?: string[];
+    required?: boolean;
+    empty?: string;
+    class?: HTMLAttributes['class'];
+    getPresignedUrl: (file: File) => Promise<PresignedUploadTarget>;
+};

package/dist/lib/lib/components/ui/filter/consts.d.ts

@@ -0,0 +1,27 @@
+import { FilterPersistenceConfig, FilterPresetConfig, FilterState, FilterValidationRule } from './types';
+export declare const DEFAULT_VALIDATION_RULES: FilterValidationRule;
+export declare const DEFAULT_PERSISTENCE_CONFIG: FilterPersistenceConfig;
+export declare const DEFAULT_PRESET_CONFIG: FilterPresetConfig;
+export declare const DEFAULT_FILTER_STATE: FilterState;
+export declare const VALIDATION_MESSAGES: {
+    readonly REQUIRED: "This field is required";
+    readonly MIN: (min: number) => string;
+    readonly MAX: (max: number) => string;
+    readonly MIN_LENGTH: (minLength: number) => string;
+    readonly MAX_LENGTH: (maxLength: number) => string;
+    readonly PATTERN: "Invalid format";
+    readonly MIN_LESS_THAN_MAX: "Minimum must be less than maximum";
+    readonly MIN_REQUIRED: "Minimum value is required";
+    readonly MAX_REQUIRED: "Maximum value is required";
+};
+export declare const URL_PARAM_SEPARATORS: {
+    readonly ARRAY: ",";
+    readonly RANGE: "-";
+    readonly DATE_RANGE: "_";
+};
+export declare const DEFAULT_MAX_VISIBLE_CHIPS = 5;
+export declare const FILTER_CONTAINER_BREAKPOINTS: {
+    readonly SM: 384;
+    readonly MD: 512;
+    readonly LG: 672;
+};

package/dist/lib/lib/components/ui/filter/filter-context.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey } from 'vue';
+import { FilterContextValue } from './types';
+export declare const filterKey: InjectionKey<FilterContextValue>;
+export declare function provideFilter(value: FilterContextValue): void;
+export declare function useFilterContext(): FilterContextValue;

package/dist/lib/lib/components/ui/filter/filter-field-map.utils.d.ts

@@ -0,0 +1,34 @@
+import { FilterField, FilterValue } from './types';
+export type FilterFieldConfig = {
+    type: string;
+    id: string;
+    name: string;
+    label: string;
+    placeholder?: string;
+    disabled?: boolean;
+    error?: boolean;
+    helperText?: string;
+    className?: string;
+    value?: unknown;
+    checked?: boolean;
+    mode?: 'single' | 'multiple';
+    options?: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }[];
+    maxLength?: number;
+    inputMode?: string;
+    step?: number;
+    onChange?: (event: {
+        target: {
+            value: string;
+            valueAsNumber?: number;
+        };
+    }) => void;
+    onValueChange?: (value: FilterValue) => void;
+    onCheckedChange?: (checked: boolean) => void;
+};
+type ChangeHandler = (value: FilterValue) => void;
+export declare function mapFilterFieldToFieldConfig(field: FilterField, value: FilterValue, onChange: ChangeHandler, error?: string, disabled?: boolean): FilterFieldConfig | null;
+export {};

package/dist/lib/lib/components/ui/filter/filter-persistence-main.utils.d.ts

@@ -0,0 +1,4 @@
+import { FilterPersistenceConfig, FilterSchema, FilterValues } from './types';
+export declare function persistFilterValues(config: FilterPersistenceConfig, schema: FilterSchema, values: FilterValues): Promise<void>;
+export declare function loadPersistedFilterValues(config: FilterPersistenceConfig, schema: FilterSchema): Promise<FilterValues | null>;
+export declare function clearPersistedFilterValues(config: FilterPersistenceConfig): Promise<void>;

package/dist/lib/lib/components/ui/filter/filter-persistence-presets.utils.d.ts

@@ -0,0 +1,4 @@
+import { FilterPreset } from './types';
+export declare function savePresets(strategy: 'localStorage' | 'sessionStorage', storageKey: string, presets: FilterPreset[]): boolean;
+export declare function loadPresets(strategy: 'localStorage' | 'sessionStorage', storageKey: string): FilterPreset[] | null;
+export declare function clearPresets(strategy: 'localStorage' | 'sessionStorage', storageKey: string): boolean;

package/dist/lib/lib/components/ui/filter/filter-persistence-storage.utils.d.ts

@@ -0,0 +1,4 @@
+import { FilterValues } from './types';
+export declare function saveToStorage(strategy: 'localStorage' | 'sessionStorage', storageKey: string, values: FilterValues, version?: number): boolean;
+export declare function loadFromStorage(strategy: 'localStorage' | 'sessionStorage', storageKey: string, version?: number): FilterValues | null;
+export declare function clearFromStorage(strategy: 'localStorage' | 'sessionStorage', storageKey: string, version?: number): boolean;

package/dist/lib/lib/components/ui/filter/filter-persistence-url.utils.d.ts

@@ -0,0 +1,5 @@
+import { FilterSchema, FilterValues } from './types';
+export declare function serializeToUrlParams(schema: FilterSchema, values: FilterValues, prefix?: string): URLSearchParams;
+export declare function parseFromUrlParams(schema: FilterSchema, searchParams: URLSearchParams, prefix?: string): FilterValues;
+export declare function updateUrlWithFilters(schema: FilterSchema, values: FilterValues, prefix?: string): void;
+export declare function loadFromUrl(schema: FilterSchema, prefix?: string): FilterValues | null;

package/dist/lib/lib/components/ui/filter/filter-persistence.utils.d.ts

@@ -0,0 +1,4 @@
+export * from './filter-persistence-main.utils';
+export * from './filter-persistence-presets.utils';
+export * from './filter-persistence-storage.utils';
+export * from './filter-persistence-url.utils';

package/dist/lib/lib/components/ui/filter/filter-preset.utils.d.ts

@@ -0,0 +1,5 @@
+export declare function generatePresetId(): string;
+export declare function sortPresets<T extends {
+    isDefault?: boolean;
+    createdAt: Date | string;
+}>(presets: T[]): T[];

package/dist/lib/lib/components/ui/filter/filter-schema.utils.d.ts

@@ -0,0 +1,10 @@
+import { mapFilterFieldToFieldConfig } from './filter-field-map.utils';
+import { FilterField, FilterGroup, FilterSchema, FilterValues } from './types';
+export { mapFilterFieldToFieldConfig };
+export declare function getFilterField(schema: FilterSchema, fieldId: string): FilterField | undefined;
+export declare function getGroupFields(schema: FilterSchema, group: FilterGroup): FilterField[];
+export declare function getUngroupedFields(schema: FilterSchema): FilterField[];
+export declare function getFilterFieldLabel(schema: FilterSchema, fieldId: string): string;
+export declare function getDefaultValuesFromSchema(schema: FilterSchema): FilterValues;
+export declare function isFieldVisible(field: FilterField, values: FilterValues): boolean;
+export declare function getVisibleFields(schema: FilterSchema, values: FilterValues): FilterField[];

package/dist/lib/lib/components/ui/filter/filter-validation.utils.d.ts

@@ -0,0 +1,24 @@
+import { FilterField, FilterSchema, FilterValidationErrors, FilterValidationRule, FilterValue, FilterValues } from './types';
+export declare function validateFilterValue(field: FilterField, value: FilterValue): string | null;
+export declare function validateAllFilters(schema: FilterSchema, values: FilterValues): FilterValidationErrors;
+export declare function validateField(schema: FilterSchema, fieldId: string, values: FilterValues): string | null;
+export declare function hasValidationErrors(errors: FilterValidationErrors): boolean;
+export declare function getValidationError(errors: FilterValidationErrors, fieldId: string): string | undefined;
+export declare function createValidationRule(rule: Partial<FilterValidationRule>): FilterValidationRule;
+export declare const VALIDATION_PATTERNS: {
+    readonly EMAIL: RegExp;
+    readonly URL: RegExp;
+    readonly PHONE: RegExp;
+    readonly ZIP_CODE: RegExp;
+    readonly ALPHANUMERIC: RegExp;
+    readonly NUMERIC: RegExp;
+};
+export declare const VALIDATION_PRESETS: {
+    readonly required: () => FilterValidationRule;
+    readonly email: () => FilterValidationRule;
+    readonly url: () => FilterValidationRule;
+    readonly phone: () => FilterValidationRule;
+    readonly positiveNumber: () => FilterValidationRule;
+    readonly percentage: () => FilterValidationRule;
+    readonly range: (min: number, max: number) => FilterValidationRule;
+};

package/dist/lib/lib/components/ui/filter/filter-value.utils.d.ts

@@ -0,0 +1,8 @@
+import { FilterField, FilterValue, FilterValues } from './types';
+export declare function isFilterValueEmpty(value: FilterValue): boolean;
+export declare function countActiveFilters(values: FilterValues): number;
+export declare function hasActiveFilters(values: FilterValues): boolean;
+export declare function areFilterValuesEqual(value1: FilterValue, value2: FilterValue): boolean;
+export declare function haveFiltersChanged(values1: FilterValues, values2: FilterValues): boolean;
+export declare function cleanFilterValues(values: FilterValues): FilterValues;
+export declare function formatFilterValue(field: FilterField, value: FilterValue): string;

package/dist/lib/lib/components/ui/filter/filter.store-actions.d.ts

@@ -0,0 +1,42 @@
+import { FilterPreset, FilterState, FilterValidationErrors, FilterValue, FilterValues } from './types';
+export declare const filterStoreActions: {
+    setValue(this: FilterState, payload: {
+        field: string;
+        value: FilterValue;
+    }): void;
+    setValues(this: FilterState, values: FilterValues): void;
+    clearValue(this: FilterState, field: string): void;
+    clearAllValues(this: FilterState): void;
+    applyFilters(this: FilterState): void;
+    resetToApplied(this: FilterState): void;
+    resetAll(this: FilterState): void;
+    setError(this: FilterState, payload: {
+        field: string;
+        message: string;
+    }): void;
+    setErrors(this: FilterState, errors: FilterValidationErrors): void;
+    clearError(this: FilterState, field: string): void;
+    clearAllErrors(this: FilterState): void;
+    setValidating(this: FilterState, value: boolean): void;
+    toggleOpen(this: FilterState): void;
+    setOpen(this: FilterState, open: boolean): void;
+    toggleGroup(this: FilterState, groupId: string): void;
+    setGroupExpanded(this: FilterState, payload: {
+        groupId: string;
+        expanded: boolean;
+    }): void;
+    initializeGroupStates(this: FilterState, ids: string[]): void;
+    addPreset(this: FilterState, preset: FilterPreset): void;
+    updatePreset(this: FilterState, payload: {
+        id: string;
+        updates: Partial<FilterPreset>;
+    }): void;
+    deletePreset(this: FilterState, id: string): void;
+    loadPreset(this: FilterState, id: string): void;
+    setDefaultPreset(this: FilterState, id: string | null): void;
+    setPresets(this: FilterState, presets: FilterPreset[]): void;
+    clearCurrentPreset(this: FilterState): void;
+    loadPersistedValues(this: FilterState, values: FilterValues): void;
+    setDisabled(this: FilterState, disabled: boolean): void;
+    setLiveUpdate(this: FilterState, liveUpdate: boolean): void;
+};