@shival99/z-ui 1.0.1 → 1.0.2

package/types/shival99-z-ui-components-z-timeline.d.ts

@@ -0,0 +1,98 @@
+import * as _angular_core from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { ClassValue } from 'clsx';
+import { ZIcon } from '@shival99/z-ui/components/z-icon';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+interface ZTimelineItem {
+    id?: string | number;
+    title: string;
+    description?: string;
+    time?: string;
+    icon?: ZIcon;
+    color?: 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+}
+type ZTimelineSize = 'sm' | 'default' | 'lg';
+type ZTimelineLayout = 'default' | 'reversed' | 'alternate';
+type ZTimelineLineStyle = 'solid' | 'dashed';
+type ZTimelineIconStyle = 'filled' | 'outline';
+type ZTimelineContentStyle = 'simple' | 'card';
+type ZTimelineClassType = 'item' | 'header' | 'icon' | 'iconCenter' | 'dot' | 'line' | 'dotCircle' | 'time' | 'side';
+interface ZTimelineClassOptions {
+    item?: ZTimelineItem;
+    layout?: ZTimelineLayout;
+    lineStyle?: ZTimelineLineStyle;
+    iconStyle?: ZTimelineIconStyle;
+    timeVariant?: 'default' | 'secondary' | 'outline' | 'muted';
+    side?: 'left' | 'right';
+}
+
+declare class ZTimelineComponent {
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zItems: _angular_core.InputSignal<ZTimelineItem[]>;
+    readonly zSize: _angular_core.InputSignal<ZTimelineSize>;
+    readonly zTimeVariant: _angular_core.InputSignal<"default" | "outline" | "secondary" | "muted">;
+    readonly zLineStyle: _angular_core.InputSignal<ZTimelineLineStyle>;
+    readonly zIconStyle: _angular_core.InputSignal<ZTimelineIconStyle>;
+    readonly zLayout: _angular_core.InputSignal<ZTimelineLayout>;
+    readonly zContentStyle: _angular_core.InputSignal<ZTimelineContentStyle>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected readonly isAlternate: _angular_core.Signal<boolean>;
+    protected readonly itemClasses: _angular_core.Signal<string>;
+    protected readonly dotClasses: _angular_core.Signal<string>;
+    protected readonly lineClasses: _angular_core.Signal<string>;
+    protected readonly titleClasses: _angular_core.Signal<string>;
+    protected readonly descriptionClasses: _angular_core.Signal<string>;
+    protected readonly contentClasses: _angular_core.Signal<string>;
+    protected readonly iconSize: _angular_core.Signal<"18" | "14">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTimelineComponent, "z-timeline", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zItems": { "alias": "zItems"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zTimeVariant": { "alias": "zTimeVariant"; "required": false; "isSignal": true; }; "zLineStyle": { "alias": "zLineStyle"; "required": false; "isSignal": true; }; "zIconStyle": { "alias": "zIconStyle"; "required": false; "isSignal": true; }; "zLayout": { "alias": "zLayout"; "required": false; "isSignal": true; }; "zContentStyle": { "alias": "zContentStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ZTimelineClassPipe implements PipeTransform {
+    transform(type: ZTimelineClassType, options?: ZTimelineClassOptions): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTimelineClassPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZTimelineClassPipe, "zTimelineClass", true>;
+}
+
+declare const zTimelineVariants: (props?: ({
+    zSize?: "default" | "sm" | "lg" | null | undefined;
+    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTimelineItemVariants: (props?: ({
+    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTimelineHeaderVariants: (props?: ({
+    hasIcon?: boolean | null | undefined;
+    zColor?: "default" | "primary" | "success" | "warning" | "error" | "info" | null | undefined;
+    zLineStyle?: "solid" | "dashed" | null | undefined;
+    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTimelineIconVariants: (props?: ({
+    zColor?: "default" | "primary" | "success" | "warning" | "error" | "info" | null | undefined;
+    zIconStyle?: "filled" | "outline" | null | undefined;
+    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTimelineTitleVariants: (props?: ({
+    zSize?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTimelineTimeVariants: (props?: ({
+    zVariant?: "default" | "outline" | "secondary" | "muted" | null | undefined;
+    zLayout?: "default" | "reversed" | "alternate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTimelineDescriptionVariants: (props?: ({
+    zSize?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zTimelineContentVariants: (props?: ({
+    zContentStyle?: "simple" | "card" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZTimelineVariants = VariantProps<typeof zTimelineVariants>;
+type ZTimelineItemVariants = VariantProps<typeof zTimelineItemVariants>;
+type ZTimelineHeaderVariants = VariantProps<typeof zTimelineHeaderVariants>;
+type ZTimelineIconVariants = VariantProps<typeof zTimelineIconVariants>;
+type ZTimelineTimeVariants = VariantProps<typeof zTimelineTimeVariants>;
+type ZTimelineContentVariants = VariantProps<typeof zTimelineContentVariants>;
+
+export { ZTimelineClassPipe, ZTimelineComponent, zTimelineContentVariants, zTimelineDescriptionVariants, zTimelineHeaderVariants, zTimelineIconVariants, zTimelineItemVariants, zTimelineTimeVariants, zTimelineTitleVariants, zTimelineVariants };
+export type { ZTimelineClassOptions, ZTimelineClassType, ZTimelineContentStyle, ZTimelineContentVariants, ZTimelineHeaderVariants, ZTimelineIconStyle, ZTimelineIconVariants, ZTimelineItem, ZTimelineItemVariants, ZTimelineLayout, ZTimelineLineStyle, ZTimelineSize, ZTimelineTimeVariants, ZTimelineVariants };

package/types/shival99-z-ui-components-z-toast.d.ts

@@ -0,0 +1,61 @@
+import * as _angular_core from '@angular/core';
+import { ClassValue } from 'clsx';
+import { ExternalToast } from 'ngx-sonner';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+type ZToastTheme = 'light' | 'dark' | 'system';
+type ZToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+type ZToastDir = 'ltr' | 'rtl' | 'auto';
+type ZToastType = 'default' | 'success' | 'error' | 'warning' | 'info';
+interface ZToastOptions extends ExternalToast {
+    description?: string;
+    duration?: number;
+    id?: string | number;
+}
+interface ZToastPromiseMessages<T> {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((error: unknown) => string);
+}
+
+declare class ZToastComponent {
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zVariant: _angular_core.InputSignal<"default" | "success" | "error" | "warning" | "info" | null | undefined>;
+    readonly zTheme: _angular_core.InputSignal<ZToastTheme>;
+    readonly zPosition: _angular_core.InputSignal<ZToastPosition>;
+    readonly zRichColors: _angular_core.InputSignal<boolean>;
+    readonly zExpand: _angular_core.InputSignal<boolean>;
+    readonly zDuration: _angular_core.InputSignal<number>;
+    readonly zVisibleToasts: _angular_core.InputSignal<number>;
+    readonly zCloseButton: _angular_core.InputSignal<boolean>;
+    readonly zToastOptions: _angular_core.InputSignal<ZToastOptions>;
+    readonly zDir: _angular_core.InputSignal<ZToastDir>;
+    protected readonly zClasses: _angular_core.Signal<string>;
+    protected readonly detectTheme: _angular_core.Signal<"light" | "dark">;
+    private readonly _themeService;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZToastComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZToastComponent, "z-toast, z-toaster", ["zToast"], { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zVariant": { "alias": "zVariant"; "required": false; "isSignal": true; }; "zTheme": { "alias": "zTheme"; "required": false; "isSignal": true; }; "zPosition": { "alias": "zPosition"; "required": false; "isSignal": true; }; "zRichColors": { "alias": "zRichColors"; "required": false; "isSignal": true; }; "zExpand": { "alias": "zExpand"; "required": false; "isSignal": true; }; "zDuration": { "alias": "zDuration"; "required": false; "isSignal": true; }; "zVisibleToasts": { "alias": "zVisibleToasts"; "required": false; "isSignal": true; }; "zCloseButton": { "alias": "zCloseButton"; "required": false; "isSignal": true; }; "zToastOptions": { "alias": "zToastOptions"; "required": false; "isSignal": true; }; "zDir": { "alias": "zDir"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ZToastService {
+    show(message: string, options?: ZToastOptions): string | number;
+    success(message: string, options?: ZToastOptions): string | number;
+    error(message: string, options?: ZToastOptions): string | number;
+    warning(message: string, options?: ZToastOptions): string | number;
+    info(message: string, options?: ZToastOptions): string | number;
+    loading(message: string, options?: ZToastOptions): string | number;
+    promise<T>(promise: Promise<T>, messages: ZToastPromiseMessages<T>): string | number | undefined;
+    dismiss(toastId?: string | number): void;
+    dismissAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ZToastService>;
+}
+
+declare const zToastVariants: (props?: ({
+    zVariant?: "default" | "success" | "error" | "warning" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZToastVariants = VariantProps<typeof zToastVariants>;
+
+export { ZToastComponent, ZToastService, zToastVariants };
+export type { ZToastOptions, ZToastPosition, ZToastType, ZToastVariants };

package/types/shival99-z-ui-components-z-tooltip.d.ts

@@ -0,0 +1,85 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit, OnDestroy } from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+type ZTooltipPosition = 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom';
+
+declare const zTooltipVariants: (props?: ({
+    zType?: "default" | "dark" | "light" | "primary" | "success" | "warning" | "error" | "info" | null | undefined;
+    zSize?: "default" | "sm" | "lg" | null | undefined;
+    zPosition?: "top" | "top-left" | "top-right" | "bottom" | "bottom-left" | "bottom-right" | "left" | "left-top" | "left-bottom" | "right" | "right-top" | "right-bottom" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZTooltipVariants = VariantProps<typeof zTooltipVariants>;
+
+type ZTooltipTrigger = 'hover' | 'click';
+type ZTooltipContent = string | TemplateRef<unknown>;
+interface ZTooltipConfig {
+    content?: ZTooltipContent;
+    position?: ZTooltipPosition;
+    type?: ZTooltipVariants['zType'];
+    size?: ZTooltipVariants['zSize'];
+    class?: string;
+    showDelay?: number;
+    hideDelay?: number;
+    arrow?: boolean;
+    offset?: number;
+    autoDetect?: boolean;
+    alwaysShow?: boolean;
+    maxWidth?: string;
+}
+
+declare class ZTooltipDirective implements OnInit, OnDestroy {
+    readonly zContent: _angular_core.InputSignal<ZTooltipContent>;
+    readonly zPosition: _angular_core.InputSignal<ZTooltipPosition>;
+    readonly zTrigger: _angular_core.InputSignal<ZTooltipTrigger>;
+    readonly zType: _angular_core.InputSignal<"default" | "dark" | "light" | "primary" | "success" | "warning" | "error" | "info" | null | undefined>;
+    readonly zSize: _angular_core.InputSignal<"default" | "sm" | "lg" | null | undefined>;
+    readonly zClass: _angular_core.InputSignal<string>;
+    readonly zShowDelay: _angular_core.InputSignal<number>;
+    readonly zHideDelay: _angular_core.InputSignal<number>;
+    readonly zArrow: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zDisabled: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zOffset: _angular_core.InputSignal<number>;
+    readonly zAutoDetect: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zTriggerElement: _angular_core.InputSignal<HTMLElement | null>;
+    readonly zAlwaysShow: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zMaxWidth: _angular_core.InputSignal<string>;
+    readonly zShow: _angular_core.OutputEmitterRef<void>;
+    readonly zHide: _angular_core.OutputEmitterRef<void>;
+    private readonly _overlay;
+    private readonly _overlayPositionBuilder;
+    private readonly _elementRef;
+    private readonly _renderer;
+    private readonly _destroyRef;
+    private readonly _platformId;
+    private readonly _document;
+    private _overlayRef;
+    private _componentRef;
+    private _delaySubject;
+    private _listenerCleanups;
+    private _positionSubscription;
+    private readonly _isVisible;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    show(): void;
+    private _isTextTruncated;
+    hide(): void;
+    toggle(): void;
+    private _createOverlay;
+    private _disposeOverlay;
+    private _setupDelayMechanism;
+    private _setupTriggers;
+    private _setupOutsideClick;
+    private _delay;
+    private _showTooltip;
+    private _setupTooltipHover;
+    private _hideTooltip;
+    private _cleanupListeners;
+    private _calculateArrowOffset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZTooltipDirective, "[z-tooltip], [zTooltip]", ["zTooltip"], { "zContent": { "alias": "zContent"; "required": false; "isSignal": true; }; "zPosition": { "alias": "zPosition"; "required": false; "isSignal": true; }; "zTrigger": { "alias": "zTrigger"; "required": false; "isSignal": true; }; "zType": { "alias": "zTooltipType"; "required": false; "isSignal": true; }; "zSize": { "alias": "zTooltipSize"; "required": false; "isSignal": true; }; "zClass": { "alias": "zClass"; "required": false; "isSignal": true; }; "zShowDelay": { "alias": "zShowDelay"; "required": false; "isSignal": true; }; "zHideDelay": { "alias": "zHideDelay"; "required": false; "isSignal": true; }; "zArrow": { "alias": "zArrow"; "required": false; "isSignal": true; }; "zDisabled": { "alias": "zDisabled"; "required": false; "isSignal": true; }; "zOffset": { "alias": "zOffset"; "required": false; "isSignal": true; }; "zAutoDetect": { "alias": "zAutoDetect"; "required": false; "isSignal": true; }; "zTriggerElement": { "alias": "zTriggerElement"; "required": false; "isSignal": true; }; "zAlwaysShow": { "alias": "zAlwaysShow"; "required": false; "isSignal": true; }; "zMaxWidth": { "alias": "zMaxWidth"; "required": false; "isSignal": true; }; }, { "zShow": "zShow"; "zHide": "zHide"; }, never, never, true, never>;
+}
+
+export { ZTooltipDirective, zTooltipVariants };
+export type { ZTooltipConfig, ZTooltipContent, ZTooltipTrigger, ZTooltipVariants };

package/types/shival99-z-ui-components-z-upload.d.ts

@@ -0,0 +1,136 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+type ZUploadSize = 'sm' | 'default' | 'lg';
+type ZUploadStatus = 'pending' | 'uploading' | 'success' | 'error';
+interface ZUploadFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    file?: File;
+    url?: string;
+    progress: number;
+    status: ZUploadStatus;
+}
+interface ZUploadError {
+    file: File;
+    error: string;
+}
+interface ZUploadValidator {
+    error: string;
+    message: string;
+    validate?: (files: ZUploadFile[]) => boolean;
+}
+interface ZUploadControl {
+    validate: () => void;
+    reset: () => void;
+    clearFiles: () => void;
+    openFileDialog: () => void;
+    markAsTouched: () => void;
+    markAsUntouched: () => void;
+    markAsDirty: () => void;
+    markAsPristine: () => void;
+    hasError: Signal<boolean>;
+    files: Signal<ZUploadFile[]>;
+    errorMessage: Signal<string>;
+}
+declare const formatFileSize: (bytes: number) => string;
+
+declare class ZUploadComponent implements OnInit, ControlValueAccessor {
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zLabel: _angular_core.InputSignal<string>;
+    readonly zLabelClass: _angular_core.InputSignal<string>;
+    readonly zNote: _angular_core.InputSignal<string>;
+    readonly zSize: _angular_core.InputSignal<ZUploadSize>;
+    readonly zAcceptFile: _angular_core.InputSignal<string>;
+    readonly zMultipleFile: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zMaxSize: _angular_core.InputSignal<number>;
+    readonly zMaxFiles: _angular_core.InputSignal<number>;
+    readonly zRequired: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zDisabled: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zReadonly: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zLoading: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zShowProgress: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zValidators: _angular_core.InputSignal<ZUploadValidator[]>;
+    readonly zOnUpload: _angular_core.OutputEmitterRef<ZUploadFile[]>;
+    readonly zOnRemove: _angular_core.OutputEmitterRef<ZUploadFile>;
+    readonly zOnDownload: _angular_core.OutputEmitterRef<ZUploadFile>;
+    readonly zOnError: _angular_core.OutputEmitterRef<ZUploadError>;
+    readonly zOnFileChange: _angular_core.OutputEmitterRef<File[]>;
+    readonly zControl: _angular_core.OutputEmitterRef<ZUploadControl>;
+    protected readonly fileInputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly files: _angular_core.WritableSignal<ZUploadFile[]>;
+    protected readonly inputId: string;
+    protected readonly isDragOver: _angular_core.WritableSignal<boolean>;
+    protected readonly isTouched: _angular_core.WritableSignal<boolean>;
+    private readonly _dirty;
+    private readonly _fileError;
+    private readonly _disabled;
+    private readonly _formControl;
+    private readonly _formStateVersion;
+    private readonly _isNgModel;
+    private readonly _injector;
+    private readonly _destroyRef;
+    private _onChange;
+    private _onTouched;
+    private _ngControl;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isBlocked: _angular_core.Signal<boolean>;
+    private readonly _shouldShowValidation;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected readonly errorMessage: _angular_core.Signal<string>;
+    protected readonly currentStatus: _angular_core.Signal<"default" | "error" | "disabled" | "readonly" | "active">;
+    protected readonly dropzoneClasses: _angular_core.Signal<string>;
+    protected readonly acceptTypes: _angular_core.Signal<string>;
+    protected readonly formatFileSize: (bytes: number) => string;
+    protected readonly getFileItemClasses: (file: ZUploadFile) => string;
+    ngOnInit(): void;
+    writeValue(value: ZUploadFile[] | null): void;
+    registerOnChange(fn: (value: ZUploadFile[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    updateProgress(fileId: string, progress: number): void;
+    setFileStatus(fileId: string, status: ZUploadFile['status']): void;
+    clearFiles(): void;
+    validate(): void;
+    reset(): void;
+    markAsTouched(): void;
+    markAsUntouched(): void;
+    markAsDirty(): void;
+    markAsPristine(): void;
+    private _emitControl;
+    getFiles(): File[];
+    protected openFileDialog(): void;
+    protected onFileSelected(event: Event): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    protected removeFile(file: ZUploadFile): void;
+    protected downloadFile(file: ZUploadFile): void;
+    private _getValidationErrors;
+    private _processFiles;
+    private _emitFileChange;
+    private _isValidFileType;
+    private _notifyChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZUploadComponent, "z-upload", ["zUpload"], { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zLabel": { "alias": "zLabel"; "required": false; "isSignal": true; }; "zLabelClass": { "alias": "zLabelClass"; "required": false; "isSignal": true; }; "zNote": { "alias": "zNote"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zAcceptFile": { "alias": "zAcceptFile"; "required": false; "isSignal": true; }; "zMultipleFile": { "alias": "zMultipleFile"; "required": false; "isSignal": true; }; "zMaxSize": { "alias": "zMaxSize"; "required": false; "isSignal": true; }; "zMaxFiles": { "alias": "zMaxFiles"; "required": false; "isSignal": true; }; "zRequired": { "alias": "zRequired"; "required": false; "isSignal": true; }; "zDisabled": { "alias": "zDisabled"; "required": false; "isSignal": true; }; "zReadonly": { "alias": "zReadonly"; "required": false; "isSignal": true; }; "zLoading": { "alias": "zLoading"; "required": false; "isSignal": true; }; "zShowProgress": { "alias": "zShowProgress"; "required": false; "isSignal": true; }; "zValidators": { "alias": "zValidators"; "required": false; "isSignal": true; }; }, { "zOnUpload": "zOnUpload"; "zOnRemove": "zOnRemove"; "zOnDownload": "zOnDownload"; "zOnError": "zOnError"; "zOnFileChange": "zOnFileChange"; "zControl": "zControl"; }, never, never, true, never>;
+}
+
+declare const zUploadDropzoneVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
+    zStatus?: "default" | "error" | "active" | "disabled" | "readonly" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZUploadDropzoneVariants = VariantProps<typeof zUploadDropzoneVariants>;
+declare const zUploadFileItemVariants: (props?: ({
+    zStatus?: "pending" | "uploading" | "success" | "error" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZUploadFileItemVariants = VariantProps<typeof zUploadFileItemVariants>;
+
+export { ZUploadComponent, formatFileSize, zUploadDropzoneVariants, zUploadFileItemVariants };
+export type { ZUploadControl, ZUploadDropzoneVariants, ZUploadError, ZUploadFile, ZUploadFileItemVariants, ZUploadSize, ZUploadStatus, ZUploadValidator };

package/types/shival99-z-ui-i18n.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Z-UI English translations
+ */
+declare const Z_UI_EN_TRANSLATIONS: Record<string, string>;
+
+/**
+ * Z-UI Vietnamese translations
+ */
+declare const Z_UI_VI_TRANSLATIONS: Record<string, string>;
+
+/**
+ * Z-UI Internationalization
+ *
+ * This module provides default translations for all Z-UI components.
+ * Users can override any translation by providing their own values.
+ *
+ * Key format: i18n_z_ui_{component}_{key}
+ * Example: i18n_z_ui_table_noData
+ */
+type ZUILanguage = 'en' | 'vi' | string;
+interface ZUITranslations {
+    [key: string]: string;
+}
+interface ZUITranslationSet {
+    en: ZUITranslations;
+    vi: ZUITranslations;
+    [lang: string]: ZUITranslations;
+}
+/**
+ * Default translations for Z-UI components
+ */
+declare const Z_UI_TRANSLATIONS: ZUITranslationSet;
+/**
+ * Get translations for a specific language
+ * Falls back to English if language not found
+ */
+declare function getZUITranslations(lang: ZUILanguage): ZUITranslations;
+/**
+ * Merge custom translations with Z-UI defaults
+ * Custom translations take precedence
+ */
+declare function mergeTranslations(lang: ZUILanguage, customTranslations?: ZUITranslations): ZUITranslations;
+/**
+ * Get all Z-UI translation keys
+ * Useful for documentation or tooling
+ */
+declare function getZUITranslationKeys(): string[];
+
+export { Z_UI_EN_TRANSLATIONS, Z_UI_TRANSLATIONS, Z_UI_VI_TRANSLATIONS, getZUITranslationKeys, getZUITranslations, mergeTranslations };
+export type { ZUILanguage, ZUITranslationSet, ZUITranslations };

package/types/shival99-z-ui-pipes.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import { PipeTransform, TemplateRef } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+
+type ZCapitalizeType = 'all' | 'first' | 'sentence';
+
+declare class ZCapitalizePipe implements PipeTransform {
+    transform(value: string | null | undefined, type?: ZCapitalizeType): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZCapitalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ZCapitalizePipe, "zCapitalize", true>;
+}
+
+type Z_CONTENT_TYPE = 'string' | 'html' | 'template';
+
+declare class ZContentTypePipe implements PipeTransform {
+    transform(value: string | TemplateRef<unknown> | null | undefined): Z_CONTENT_TYPE;
+    private _containsHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZContentTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ZContentTypePipe, "zContentType", true>;
+}
+
+declare class ZHighlightPipe implements PipeTransform {
+    transform(value: string, searchText: string, klass?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZHighlightPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ZHighlightPipe, "zHighlight", true>;
+}
+
+declare class ZSafeHtmlPipe implements PipeTransform {
+    private _sanitizer;
+    transform(value: string | null | undefined): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZSafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ZSafeHtmlPipe, "zSafeHtml", true>;
+}
+
+export { ZCapitalizePipe, ZContentTypePipe, ZHighlightPipe, ZSafeHtmlPipe };
+export type { ZCapitalizeType, Z_CONTENT_TYPE };

package/types/shival99-z-ui-providers.d.ts

@@ -0,0 +1,132 @@
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { ZIndexDbConfig, ZIndexDbService } from '@shival99/z-ui/services';
+import { HttpClient } from '@angular/common/http';
+import { TranslateLoader } from '@ngx-translate/core';
+import { ZUITranslations } from '@shival99/z-ui/i18n';
+
+/**
+ * Z-IndexDB Provider
+ * Provides IndexDB service with multi-store configuration
+ */
+
+/** Injection token for ZIndexDbService */
+declare const Z_INDEXDB_SERVICE: InjectionToken<ZIndexDbService>;
+/**
+ * Provide Z-IndexDB service with configuration
+ * @param config - IndexDB configuration with multi-store support
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideZIndexDb({
+ *       dbName: 'MyApp',
+ *       version: 1,
+ *       stores: [
+ *         { name: 'cache', encrypt: true },
+ *         { name: 'userData', encrypt: true, protectedKeys: ['profile'] },
+ *         { name: 'settings', encrypt: false },
+ *       ],
+ *       defaultStore: 'cache',
+ *       protectedKeys: ['token'],
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+declare function provideZIndexDb(config?: ZIndexDbConfig): EnvironmentProviders;
+
+/**
+ * Z-NgxMask Provider Types
+ */
+interface ZNgxMaskConfig {
+    /** Language code (vi, en, etc.) */
+    lang?: string;
+    /** Allow negative numbers */
+    allowNegativeNumbers?: boolean;
+    /** Enable validation */
+    validation?: boolean;
+}
+
+/**
+ * Z-NgxMask Provider
+ * Provides ngx-mask configuration based on locale
+ */
+
+/**
+ * Provide Z-NgxMask with locale-aware configuration
+ * @param config - Mask configuration
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideZNgxMask({ lang: 'vi' }),
+ *   ],
+ * };
+ * ```
+ */
+declare function provideZNgxMask(config?: ZNgxMaskConfig): EnvironmentProviders;
+
+/**
+ * Provides global scrollbar options for ngx-scrollbar
+ * Use this in app.config.ts: providers: [provideZScrollbar()]
+ */
+declare function provideZScrollbar(): EnvironmentProviders;
+
+/**
+ * Z-Translate Provider Types
+ */
+
+interface ZTranslateProviderConfig {
+    /** Default language (default: 'vi') */
+    defaultLang?: string;
+    /** Path to user translation files (default: './assets/i18n/') */
+    translationPath?: string;
+    /** File extension for translation files (default: '.json') */
+    fileExtension?: string;
+    /**
+     * Whether to include Z-UI default translations (default: true)
+     * Z-UI translations are merged with user translations,
+     * user translations take precedence
+     */
+    includeZUITranslations?: boolean;
+    /**
+     * Path to Z-UI translation override files (optional)
+     * If set, will load translations from this path to override Z-UI defaults
+     * Example: './assets/i18n/z-ui/' will load './assets/i18n/z-ui/vi.json'
+     *
+     * File format:
+     * ```json
+     * {
+     *   "i18n_z_ui_table_noData": "Bảng trống"
+     * }
+     * ```
+     */
+    zuiOverridePath?: string;
+    /**
+     * Inline custom translations to override Z-UI defaults (optional)
+     * Use this for simple overrides without creating separate files
+     *
+     * @example
+     * ```typescript
+     * customZUITranslations: {
+     *   vi: { i18n_z_ui_table_noData: 'Bảng trống' },
+     *   en: { i18n_z_ui_table_noData: 'Empty table' },
+     * }
+     * ```
+     */
+    customZUITranslations?: Partial<Record<string, ZUITranslations>>;
+}
+
+declare function zCreateTranslateLoader(http: HttpClient, path?: string, extension?: string, includeZUI?: boolean, zuiOverridePath?: string, customZUI?: Partial<Record<string, ZUITranslations>>): TranslateLoader;
+/**
+ * Provide Z-Translate service
+ * Z-UI translations are auto-included by default
+ */
+declare function provideZTranslate(config?: ZTranslateProviderConfig): EnvironmentProviders;
+
+export { Z_INDEXDB_SERVICE, provideZIndexDb, provideZNgxMask, provideZScrollbar, provideZTranslate, zCreateTranslateLoader };
+export type { ZNgxMaskConfig, ZTranslateProviderConfig };