@xlabs-store/core 0.0.1

package/dist/types/types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * XLabs Component Types
+ *
+ * Central export file for all component types
+ */
+export type { SelectOption, LabeledValue, OptionGroup, SelectValue, SelectMode, SelectSize, SelectStatus, SelectPlacement, SelectShowAction, SelectChangeEventDetail, XSelectOptionElement, } from './components/x-select/types';
+export type { SelectDropdownRefCallback } from './components/x-select/select-dropdown-content/types';
+export type { DatePickerMode, DatePickerSize, DatePickerStatus, DatePickerPlacement, DatePickerChangeEventDetail, DateType, } from './components/x-date-picker/types';
+export type { YearCellClickDetail, MonthCellClickDetail, DateCellClickDetail, QuarterCellClickDetail, WeekCellClickDetail, HeaderActionDetail, } from './components/x-date-picker/date-picker-dropdown-content/types';
+export type { InputSize, InputStatus, InputVariant, InputType, InputChangeEventDetail, InputFocusEventDetail } from './components/x-input/types';
+export type { InputNumberChangeEventDetail, InputNumberStepEventDetail } from './components/x-input-number/types';
+export type { TimePickerSize, TimePickerStatus, TimePickerPlacement, TimePickerChangeEventDetail, DisabledTimeConfig } from './components/x-time-picker/types';
+export type { TreeSelectNode, TreeSelectSize, TreeSelectStatus, TreeSelectPlacement, TreeSelectVariant, TreeSelectShowCheckedStrategy, TreeSelectLabeledValue, TreeSelectFieldNames, TreeSelectChangeEventDetail, TreeSelectSelectEventDetail, TreeSelectExpandEventDetail, TreeSelectSearchEventDetail, TreeSelectDropdownVisibleChangeDetail, } from './components/x-tree-select/types';
+export type { TreeNode, TreeExpandEvent, TreeSelectEvent, TreeCheckEvent, TreeDragEvent, TreeLoadDataEvent } from './components/x-tree/types';
+export type { TransferItem, TransferDirection, TransferListStyle, TransferPagination, TransferChangeEvent, TransferSelectChangeEvent, TransferSearchEvent, TransferScrollEvent, TransferRenderInfo, } from './components/x-transfer/types';
+export type { CascaderOption, CascaderFieldNames, CascaderSize, CascaderStatus, CascaderPlacement, CascaderVariant, CascaderExpandTrigger, CascaderChangeEventDetail, CascaderSearchEventDetail, CascaderDropdownVisibleChangeDetail, CascaderLoadDataEventDetail, } from './components/x-cascader/types';
+export type { CascaderMenuItemClickDetail, CascaderMenuItemHoverDetail } from './components/x-cascader/cascader-dropdown-content/types';
+export type { CollapseSize, CollapseCollapsible, CollapseExpandIconPosition, CollapseActiveKey, CollapseItem, CollapseChangeEventDetail, CollapsePanelClickEventDetail, } from './components/x-collapse/types';
+export type { TagVariant, TagPresetColor, TagCloseEventDetail, TagCheckEventDetail } from './components/x-tag/types';
+export type { AvatarShape, AvatarSize, AvatarErrorEventDetail } from './components/x-avatar/types';
+export type { BadgeStatus, BadgeSize, BadgePresetColor, BadgeOffset, RibbonPlacement } from './components/x-badge/types';
+export type { CommentAuthor, CommentData } from './components/x-comment/types';
+export type { DescriptionsSize, DescriptionsLayout, DescriptionsLabelStyle, DescriptionsContentStyle, DescriptionsItemData, DescriptionsColumnConfig, } from './components/x-descriptions/types';
+export type { ImagePreviewType, ImagePreviewConfig, ImageTransform, ImageAction, ToolbarRenderInfo, ImageErrorEventDetail, ImageLoadEventDetail, ImagePreviewVisibleChangeEventDetail, } from './components/x-image/types';
+export type { ResultStatus, ResultClassNames, ResultStyles } from './components/x-result/types';
+export type { TooltipPlacement, TooltipTrigger, TooltipArrowConfig, TooltipClassNames, TooltipStyles, TooltipOpenChangeEventDetail } from './components/x-tooltip/types';
+export type { RadioChangeEventDetail, RadioClassNames, RadioStyles, RadioSize, RadioButtonStyle, RadioOptionType, RadioOrientation, RadioOption } from './components/x-radio/types';
+export type { CheckboxChangeEventDetail, CheckboxClassNames, CheckboxStyles, CheckboxOption, CheckboxGroupChangeEventDetail } from './components/x-checkbox/types';
+export type { StepStatus, StepsDirection, StepsSize, StepsType, StepsTitlePlacement, StepsVariant, StepItem, StepsClassNames, StepsStyles, StepsChangeEventDetail, } from './components/x-steps/types';
+export type { TabsPlacement, TabsType, TabsSize, TabsIndicatorAlign, TabsIndicator, TabsAnimatedConfig, TabsAnimated, TabBarExtraContent, TabItem, TabsClassNames, TabsStyles, TabsChangeEventDetail, TabsEditEventDetail, TabsClickEventDetail, TabsScrollEventDetail, TabsMoreProps, } from './components/x-tabs/types';
+export type { MenuSelectDetail, MenuDeselectDetail, MenuClickDetail, MenuOpenChangeDetail } from './components/x-menu/types';
+export type { MenuItemClickDetail } from './components/x-menu-item/types';
+export type { SubmenuToggleDetail, SubmenuTitleClickDetail } from './components/x-menu-submenu/types';
+export type { TableSize, TableLayout, TableScroll, SortOrder, ColumnAlign, ColumnFixed, FilterItem, FilterMode, SorterConfig, TableColumn, TablePagination, RowSelectionType, SelectionItem, TableRowSelection, TableExpandable, SortState, FilterState, TableClassNames, TableStyles, TableChangeEventDetail, TableRowEventDetail, TableSelectionChangeEventDetail, TableExpandEventDetail, TableColumnSortEventDetail, TableRowSortEventDetail, } from './components/x-table/types';
+export type { PaginationSize, PaginationAlign, PaginationItemType, PaginationSimple, PaginationQuickJumper, PaginationChangeEventDetail, PaginationShowSizeChangeEventDetail, PaginationClassNames, PaginationStyles, } from './components/x-pagination/types';
+export type { DropdownPlacement, DropdownTrigger, DropdownArrow, DropdownMenuItem, DropdownMenu, DropdownOpenChangeSource, DropdownOpenChangeEventDetail, DropdownMenuClickEventDetail, DropdownClassNames, DropdownStyles, } from './components/x-dropdown/types';
+export type { ModalConfig, ModalInstance, ModalMethodType, IModalService, ModalCreateConfig, ModalCreateInstance, ModalContentType, ModalRef, ModalEventEmitter, ModalButtonOptions, } from './components/x-modal/modal-service.types';
+export type { NotificationType, NotificationPlacement, NotificationConfig, NotificationInstance, NotificationGlobalConfig, INotificationService, } from './components/x-notification/types';
+export type { RangePickerChangeEventDetail } from './components/x-range-picker/types';
+export type { RangeDateClickDetail, RangeHeaderActionDetail, PresetClickDetail, RangeTimeChangeDetail } from './components/x-range-picker/range-picker-dropdown-content/types';
+export type { MessageType, MessageConfig, MessageInstance, MessageGlobalConfig, IMessageService } from './components/x-message/types';
+export type { ColorChangeEventDetail, Color, FormatChangeEventDetail, OpenChangeEventDetail } from './components/x-color-picker/types';
+export { Modal } from './components/x-modal/modal-service';
+export { message } from './components/x-message/message-service';
+export { notification } from './components/x-notification/notification-service';
+export type { SliderValue } from './components/x-slider/types';
+export type { TourStep } from './components/x-tour/types';
+export type { SegmentedValue, SegmentedOption } from './components/x-segmented/types';
+export type { UploadChangeEventDetail, UploadRemoveEventDetail, UploadPreviewEventDetail, UploadDownloadEventDetail, UploadDropEventDetail, UploadFile, UploadStatus, UploadListType, } from './components/x-upload/types';
+export type { SplitterCollapseDetail } from './components/x-splitter/types';
+export type { PanelResizeStartDetail, PanelCollapseDetail } from './components/x-splitter-panel/types';
+export type { SwitchClickEvent } from './components/x-switch/types';
+export type { StepClickEventDetail } from './components/x-step/types';
+export type { TreeNodeClickDetail, TreeNodeExpandDetail, TreeNodeCheckDetail } from './components/x-tree-select/tree-select-dropdown-content/types';
+export type { TimeChangeDetail } from './components/x-time-picker/time-picker-dropdown-content/types';
+export type { MentionOption } from './components/x-mentions/types';
+export type { AutoCompleteSize, AutoCompleteStatus, AutoCompleteVariant, AutoCompleteOption, AutoCompleteOptionGroup, AutoCompleteChangeEventDetail, AutoCompleteSelectEventDetail, AutoCompleteSearchEventDetail, AutoCompleteOpenChangeEventDetail, AutoCompletePopupScrollEventDetail, } from './components/x-auto-complete/types';
+export type { AutoCompleteDropdownRefCallback } from './components/x-auto-complete/auto-complete-dropdown-content/types';
+export type { ScrollDetail } from './components/x-content/types';

package/dist/types/utils/app-service.d.ts

@@ -0,0 +1,20 @@
+import type { IMessageService } from '../components/x-message/types';
+import type { IModalService } from '../components/x-modal/modal-service.types';
+import type { INotificationService } from '../components/x-notification/types';
+export interface AppInstance {
+    message: IMessageService;
+    modal: IModalService;
+    notification: INotificationService;
+}
+/**
+ * Register the global app instance
+ */
+export declare const registerApp: (instance: AppInstance) => void;
+/**
+ * Unregister the global app instance
+ */
+export declare const unregisterApp: () => void;
+/**
+ * Get the currently active global app instance
+ */
+export declare const getAppInstance: () => AppInstance | null;

package/dist/types/utils/cascader.service.d.ts

@@ -0,0 +1,45 @@
+export interface CascaderFieldNames {
+    value?: string;
+    label?: string;
+    children?: string;
+}
+export declare class CascaderService<T extends Record<string, unknown>> {
+    private valueKey;
+    private labelKey;
+    private childrenKey;
+    constructor(fieldNames?: CascaderFieldNames);
+    /**
+     * Get option value
+     */
+    getValue(option: T): string;
+    /**
+     * Get option label
+     */
+    getLabel(option: T): string;
+    /**
+     * Get option children
+     */
+    getChildren(option: T): T[] | undefined;
+    /**
+     * Find an option path based on an array of values
+     */
+    findOptionPath(options: T[], valuePath: string[]): T[];
+    /**
+     * Calculate active options (columns representation) from a selected path
+     * @param options The root options
+     * @param path The selected path of options
+     */
+    getActiveOptionsFromPath(options: T[], path: T[]): T[][];
+    /**
+     * Filter cascader options based on search value
+     */
+    filterOptions(options: T[], searchValue: string, filterFn?: (inputValue: string, path: T[]) => boolean, currentPath?: T[]): T[];
+    /**
+     * Get the path to the first leaf node in a tree
+     */
+    getFirstPath(options: T[]): T[];
+    /**
+     * Get the path to the first matching node in the tree
+     */
+    getFirstMatchingPath(options: T[], searchValue: string, filterFn?: (inputValue: string, path: T[]) => boolean, currentPath?: T[]): T[];
+}

package/dist/types/utils/config.d.ts

@@ -0,0 +1,47 @@
+export interface GlobalIconConfig {
+    search?: string;
+    clear?: string;
+    close?: string;
+    delete?: string;
+    remove?: string;
+    check?: string;
+    checkSmall?: string;
+    loading?: string;
+    upload?: string;
+    date?: string;
+    time?: string;
+    calendar?: string;
+    arrowDown?: string;
+    arrowUp?: string;
+    arrowLeft?: string;
+    arrowRight?: string;
+    doubleArrowLeft?: string;
+    doubleArrowRight?: string;
+    visibility?: string;
+    visibilityOff?: string;
+    file?: string;
+    more?: string;
+    paperClip?: string;
+    picture?: string;
+    eye?: string;
+    download?: string;
+    plus?: string;
+    inbox?: string;
+    zoomIn?: string;
+    zoomOut?: string;
+    rotateLeft?: string;
+    rotateRight?: string;
+    flipX?: string;
+    flipY?: string;
+    success?: string;
+    error?: string;
+    warning?: string;
+    info?: string;
+    [key: string]: string | undefined;
+}
+export interface GlobalConfig {
+    icons: GlobalIconConfig;
+}
+export declare const setGlobalConfig: (config: Partial<GlobalConfig>) => void;
+export declare const getIcon: (key: keyof GlobalIconConfig) => string;
+export declare const getGlobalConfig: () => GlobalConfig;

package/dist/types/utils/form/core/abstract-control.d.ts

@@ -0,0 +1,121 @@
+import { ValidatorFn, AsyncValidatorFn, ValidationErrors, AbstractControlStatus, FormValue } from '../types';
+type ChangeListener = (value: FormValue) => void;
+type StatusChangeListener = (status: AbstractControlStatus) => void;
+/**
+ * AbstractControl — Base class mirroring Angular's AbstractControl
+ * Provides: value, status, errors, dirty, touched, pristine, valid, invalid
+ */
+export declare abstract class AbstractControl<T = FormValue> {
+    protected _value: T;
+    protected _status: AbstractControlStatus;
+    protected _errors: ValidationErrors | null;
+    protected _validators: ValidatorFn[];
+    protected _asyncValidators: AsyncValidatorFn[];
+    protected _updateOn: 'change' | 'blur' | 'submit';
+    protected _dirty: boolean;
+    protected _touched: boolean;
+    protected _pending: boolean;
+    protected _onChange: ChangeListener[];
+    protected _onStatusChange: StatusChangeListener[];
+    protected _valueChangeListeners: Set<ChangeListener>;
+    protected _statusChangeListeners: Set<StatusChangeListener>;
+    protected _stateChangeListeners: Set<(state: {
+        value: T;
+        status: AbstractControlStatus;
+        errors: ValidationErrors | null;
+    }) => void>;
+    parent: AbstractControl | null;
+    abstract get value(): T;
+    getRawValue(): T;
+    get valid(): boolean;
+    get invalid(): boolean;
+    get pending(): boolean;
+    get disabled(): boolean;
+    get enabled(): boolean;
+    get dirty(): boolean;
+    get pristine(): boolean;
+    get touched(): boolean;
+    get untouched(): boolean;
+    get status(): AbstractControlStatus;
+    get errors(): ValidationErrors | null;
+    get updateOn(): 'change' | 'blur' | 'submit';
+    /**
+     * Subscribe to value changes — returns unsubscribe fn
+     */
+    valueChanges(listener: ChangeListener): () => void;
+    /**
+     * Subscribe to status changes — returns unsubscribe fn
+     */
+    statusChanges(listener: StatusChangeListener): () => void;
+    /**
+     * Subscribe to state changes (value + status + errors)
+     */
+    stateChanges(listener: (state: {
+        value: T;
+        status: AbstractControlStatus;
+        errors: ValidationErrors | null;
+    }) => void): () => void;
+    abstract setValue(value: T, options?: object): void;
+    abstract patchValue(value: T, options?: object): void;
+    abstract reset(formState?: FormValue, options?: object): void;
+    markAsDirty(opts?: {
+        onlySelf?: boolean;
+    }): void;
+    markAsPristine(opts?: {
+        onlySelf?: boolean;
+    }): void;
+    markAsTouched(opts?: {
+        onlySelf?: boolean;
+    }): void;
+    markAsUntouched(opts?: {
+        onlySelf?: boolean;
+    }): void;
+    markAllAsTouched(): void;
+    markAllAsDirty(): void;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    setValidators(validators: ValidatorFn | ValidatorFn[] | null): void;
+    addValidators(validators: ValidatorFn | ValidatorFn[]): void;
+    removeValidators(validators: ValidatorFn | ValidatorFn[]): void;
+    clearValidators(): void;
+    hasValidator(validator: ValidatorFn): boolean;
+    setAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[] | null): void;
+    clearAsyncValidators(): void;
+    setErrors(errors: ValidationErrors | null, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    getError(errorCode: string, path?: string | (string | number)[]): any;
+    hasError(errorCode: string, path?: string | (string | number)[]): boolean;
+    get(path: string | (string | number)[]): AbstractControl | null;
+    get root(): AbstractControl;
+    protected _applyValidators(validatorsOrOptions?: ValidatorFn | ValidatorFn[] | {
+        validators?: ValidatorFn | ValidatorFn[];
+        asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[];
+    }, asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[]): void;
+    protected _runValidators(_value: FormValue): ValidationErrors | null;
+    protected _runAsyncValidators(_value: FormValue): Promise<void>;
+    protected _setErrors(errors: ValidationErrors | null, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected _updateValueAndValidity(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    protected _calculateStatus(): AbstractControlStatus;
+    protected _emitValueChange(value: T): void;
+    protected _emitStatusChange(status: AbstractControlStatus): void;
+    protected _emitStateChange(): void;
+    protected _updateDirty(): void;
+    protected _updateTouched(): void;
+    protected _anyControls(_condition: (c: AbstractControl) => boolean): boolean;
+    protected _forEachChild(_fn: (c: AbstractControl) => void): void;
+    protected abstract _runValidation(): void;
+    protected _coerceToArray<F>(v?: F | F[] | null): F[];
+}
+export {};

package/dist/types/utils/form/core/form-array.d.ts

@@ -0,0 +1,51 @@
+import { ValidatorFn, AsyncValidatorFn, FormValue } from '../types';
+import { AbstractControl } from './abstract-control';
+/**
+ * FormArray — Manages an array of controls
+ * Mirrors Angular's FormArray API 100%
+ */
+export declare class FormArray extends AbstractControl {
+    private _controlsList;
+    constructor(controls: AbstractControl[], validatorsOrOptions?: ValidatorFn | ValidatorFn[] | {
+        validators?: ValidatorFn | ValidatorFn[];
+        asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[];
+    }, asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[]);
+    get value(): FormValue[];
+    get controls(): AbstractControl[];
+    get length(): number;
+    at(index: number): AbstractControl;
+    push(control: AbstractControl, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    insert(index: number, control: AbstractControl, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    removeAt(index: number, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    setControl(index: number, control: AbstractControl, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    clear(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    setValue(value: FormValue[], options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    patchValue(value: FormValue[], options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    reset(value?: FormValue[], options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    getRawValue(): FormValue[];
+    protected _runValidation(): void;
+    protected _forEachChild(fn: (c: AbstractControl, i: number | string) => void): void;
+    protected _anyControls(condition: (c: AbstractControl) => boolean): boolean;
+    private _setParentForControls;
+    private _checkAllValuesPresent;
+    private _throwIfControlMissing;
+}

package/dist/types/utils/form/core/form-builder.d.ts

@@ -0,0 +1,45 @@
+import { ValidatorFn, AsyncValidatorFn, FormValue } from '../types';
+import { AbstractControl } from './abstract-control';
+import { FormControl, FormControlOptions } from './form-control';
+import { FormGroup } from './form-group';
+import { FormArray } from './form-array';
+type ControlConfig = FormValue | [FormValue, (ValidatorFn | ValidatorFn[] | FormControlOptions)?, (AsyncValidatorFn | AsyncValidatorFn[])?];
+/**
+ * FormBuilder — Shorthand service for creating form structures
+ * Mirrors Angular's FormBuilder API 100%
+ *
+ * Usage:
+ *   const fb = new FormBuilder();
+ *   const form = fb.group({
+ *     email: ['', [Validators.required, Validators.email]],
+ *     password: fb.control('', Validators.minLength(8))
+ *   });
+ */
+export declare class FormBuilder {
+    /**
+     * Creates a FormGroup from a config object
+     */
+    group<T extends {
+        [K: string]: ControlConfig | AbstractControl;
+    }>(controlsConfig: T, options?: ValidatorFn | ValidatorFn[] | {
+        validators?: ValidatorFn | ValidatorFn[];
+        asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[];
+    } | null): FormGroup;
+    /**
+     * Creates a FormControl
+     */
+    control<T = FormValue>(formState: T | {
+        value: T;
+        disabled: boolean;
+    }, validatorsOrOptions?: ValidatorFn | ValidatorFn[] | FormControlOptions, asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[]): FormControl<T>;
+    /**
+     * Creates a FormArray
+     */
+    array(controlsConfig: ControlConfig[], validatorsOrOptions?: ValidatorFn | ValidatorFn[] | {
+        validators?: ValidatorFn | ValidatorFn[];
+        asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[];
+    }, asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[]): FormArray;
+    private _createControl;
+}
+export declare const fb: FormBuilder;
+export {};

package/dist/types/utils/form/core/form-control.d.ts

@@ -0,0 +1,37 @@
+import { ValidatorFn, AsyncValidatorFn, FormValue } from '../types';
+import { AbstractControl } from './abstract-control';
+export interface FormControlOptions {
+    validators?: ValidatorFn | ValidatorFn[] | null;
+    asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[] | null;
+    updateOn?: 'change' | 'blur' | 'submit';
+}
+/**
+ * FormControl — Tracks value & validity of an individual form control
+ * Mirrors Angular's FormControl API 100%
+ */
+export declare class FormControl<T = FormValue> extends AbstractControl<T> {
+    constructor(formState?: T | {
+        value: T;
+        disabled: boolean;
+    }, validatorsOrOptions?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    get value(): T;
+    setValue(value: T, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+        emitModelToViewChange?: boolean;
+        emitViewToModelChange?: boolean;
+    }): void;
+    patchValue(value: T, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+        emitModelToViewChange?: boolean;
+        emitViewToModelChange?: boolean;
+    }): void;
+    reset(formState?: FormValue, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    private _initialize;
+    private _isFormControlOptions;
+    protected _runValidation(): void;
+}

package/dist/types/utils/form/core/form-group.d.ts

@@ -0,0 +1,63 @@
+import { ValidatorFn, AsyncValidatorFn, FormValue } from '../types';
+import { AbstractControl } from './abstract-control';
+export type FormGroupControls = {
+    [key: string]: AbstractControl;
+};
+/**
+ * FormGroup — Tracks values & validity of a group of controls
+ * Mirrors Angular's FormGroup API 100%
+ */
+export declare class FormGroup<T extends FormGroupControls = FormGroupControls> extends AbstractControl {
+    protected _controls: T;
+    constructor(controls: T, validatorsOrOptions?: ValidatorFn | ValidatorFn[] | {
+        validators?: ValidatorFn | ValidatorFn[];
+        asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[];
+    }, asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[]);
+    get value(): {
+        [K in keyof T]: T[K]['value'];
+    };
+    get controls(): T;
+    registerControl(name: string, control: AbstractControl): AbstractControl;
+    addControl(name: string, control: AbstractControl, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    removeControl(name: string, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    setControl<K extends keyof T>(name: K, control: T[K], opts?: {
+        emitEvent?: boolean;
+    }): void;
+    contains(controlName: string): boolean;
+    setValue(value: {
+        [K in keyof T]: any;
+    }, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    patchValue(value: {
+        [K in keyof T]?: any;
+    }, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    reset(value?: {
+        [K in keyof T]?: any;
+    }, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    getRawValue(): {
+        [K in keyof T]: FormValue;
+    };
+    protected _runValidation(): void;
+    protected _computeStatus(): 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
+    private _collectChildErrors;
+    private _anyControlsHaveStatus;
+    protected _forEachChild(fn: (control: AbstractControl, name: string) => void): void;
+    protected _anyControls(condition: (c: AbstractControl) => boolean): boolean;
+    private _reduceValue;
+    private _reduceChildren;
+    private _setParentForControls;
+    private _checkAllValuesPresent;
+    private _throwIfControlMissing;
+}

package/dist/types/utils/form/frameworks.d.ts

@@ -0,0 +1,18 @@
+import { AbstractControl } from './core/abstract-control';
+/**
+ * React Hook for using AbstractControl in functional components
+ * Syncs value and status changes with React's re-render cycle
+ *
+ * Usage:
+ *   const form = useForm(fb.group({ ... }));
+ *   return <input value={form.controls.email.value} onChange={(e) => form.controls.email.setValue(e.target.value)} />
+ */
+export declare function useForm<T extends AbstractControl>(control: T): T;
+/**
+ * Vue Composable for using AbstractControl in Setup API
+ * Converts AbstractControl into a reactive-like object
+ */
+export declare function useVueForm<T extends AbstractControl>(control: T): T;
+/**
+ * Angular adapter is built-in as the API matches 1:1
+ */

package/dist/types/utils/form/types.d.ts

@@ -0,0 +1,8 @@
+import type { AbstractControl } from "./core/abstract-control";
+export type FormValue = any;
+export type AbstractControlStatus = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
+export type ValidationErrors = {
+    [key: string]: FormValue;
+};
+export type ValidatorFn = (control: AbstractControl) => ValidationErrors | null;
+export type AsyncValidatorFn = (control: AbstractControl) => Promise<ValidationErrors | null>;

package/dist/types/utils/form/validators/validators.d.ts

@@ -0,0 +1,39 @@
+import { ValidatorFn, ValidationErrors, AsyncValidatorFn } from '../types';
+import { AbstractControl } from '../core/abstract-control';
+/**
+ * Validators — Mirrors Angular's Validators class 100%
+ * All built-in validators + compose utilities
+ */
+export declare class Validators {
+    static required(control: AbstractControl): ValidationErrors | null;
+    static requiredTrue(control: AbstractControl): ValidationErrors | null;
+    static email(control: AbstractControl): ValidationErrors | null;
+    static minLength(minLength: number): ValidatorFn;
+    static maxLength(maxLength: number): ValidatorFn;
+    static min(min: number): ValidatorFn;
+    static max(max: number): ValidatorFn;
+    static pattern(pattern: string | RegExp): ValidatorFn;
+    static nullValidator(_control: AbstractControl): ValidationErrors | null;
+    static url(control: AbstractControl): ValidationErrors | null;
+    static integer(control: AbstractControl): ValidationErrors | null;
+    static numeric(control: AbstractControl): ValidationErrors | null;
+    static whitespace(control: AbstractControl): ValidationErrors | null;
+    static range(min: number, max: number): ValidatorFn;
+    /**
+     * Validates that password and confirmPassword match
+     */
+    static mustMatch(controlName: string, matchingControlName: string): ValidatorFn;
+    /**
+     * Compose multiple validators into one (stops at first error OR merges all)
+     */
+    static compose(validators: (ValidatorFn | null | undefined)[] | null): ValidatorFn | null;
+    /**
+     * Compose async validators
+     */
+    static composeAsync(validators: (AsyncValidatorFn | null)[] | null): AsyncValidatorFn | null;
+    /**
+     * Creates an async validator that checks uniqueness via a custom check fn
+     * Example: Validators.uniqueAsync(async (v) => await checkEmailExists(v))
+     */
+    static uniqueAsync(checkFn: (value: any) => Promise<boolean>): AsyncValidatorFn;
+}

package/dist/types/utils/index.d.ts

@@ -0,0 +1,10 @@
+export type Placement = 'top' | 'bottom' | 'left' | 'right';
+export interface PositionOptions {
+    placement?: Placement;
+    offset?: number;
+    padding?: number;
+    flip?: boolean;
+}
+export * from './tree.service';
+export * from './cascader.service';
+export * from './table.service';

package/dist/types/utils/qr-code/cache/qr.cache.d.ts

@@ -0,0 +1,7 @@
+export declare class QRCache {
+    map: Map<string, any>;
+    max: number;
+    get(k: string): any;
+    set(k: string, v: any): void;
+}
+export declare const qrCache: QRCache;

package/dist/types/utils/qr-code/engine/qr.engine.d.ts

@@ -0,0 +1,15 @@
+import { EC } from './qr.version';
+export declare class QREngine {
+    data: string;
+    ec: EC;
+    size: number;
+    matrix: number[][];
+    reserved: boolean[][];
+    constructor(data: string, ec?: EC);
+    set(x: number, y: number, v: number): void;
+    patterns(): void;
+    formatInfo(mask: number): void;
+    encode(): number[];
+    place(bits: number[]): void;
+    build(): number[][];
+}

package/dist/types/utils/qr-code/engine/qr.gf.d.ts

@@ -0,0 +1,4 @@
+export declare const GF_EXP: any[];
+export declare const GF_LOG: any[];
+export declare function gfMul(x: number, y: number): any;
+export declare function gfPow(x: number, y: number): any;

package/dist/types/utils/qr-code/engine/qr.mask.d.ts

@@ -0,0 +1,2 @@
+export declare function applyMask(matrix: number[][], reserved: boolean[][], mask: number): void;
+export declare function score(m: number[][]): number;

package/dist/types/utils/qr-code/engine/qr.rs.d.ts

@@ -0,0 +1 @@
+export declare function reedSolomon(data: number[], ecCount: number): any[];

package/dist/types/utils/qr-code/engine/qr.version.d.ts

@@ -0,0 +1,16 @@
+export type EC = 'L' | 'M' | 'Q' | 'H';
+export declare const CAP: {
+    1: {
+        L: number;
+        M: number;
+        Q: number;
+        H: number;
+    };
+    2: {
+        L: number;
+        M: number;
+        Q: number;
+        H: number;
+    };
+};
+export declare function getVersion(len: number, ec: EC): number;

package/dist/types/utils/qr-code/renderer/canvas.renderer.d.ts

@@ -0,0 +1,6 @@
+export interface CanvasRenderOptions {
+    logo?: string;
+    color?: string;
+    bgColor?: string;
+}
+export declare function renderCanvas(canvas: HTMLCanvasElement, matrix: number[][], size: number, options?: CanvasRenderOptions): Promise<void>;

package/dist/types/utils/qr-code/renderer/svg.renderer.d.ts

@@ -0,0 +1,7 @@
+export interface SVGRenderOptions {
+    gradient?: boolean;
+    logo?: string;
+    color?: string;
+    bgColor?: string;
+}
+export declare function renderSVG(matrix: number[][], size: number, options?: SVGRenderOptions): string;