quang 19.0.19-2

package/README.md

@@ -0,0 +1,25 @@
+# Quang
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project quang` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project quang`.
+
+> Note: Don't forget to add `--project quang` or else it will be added to the default project in your `angular.json` file.
+
+## Build
+
+Run `ng build quang` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build quang`, go to the dist folder `cd dist/quang` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test quang` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/auth/README.md

@@ -0,0 +1,160 @@
+# Quang Auth
+
+Quang Auth provides a comprehensive set of tools and utilities based on OIDC (Open ID Connect) for managing
+authentication within your Angular application.
+
+This service encapsulates authentication logic, making it reusable and maintainable across different parts of your
+application.
+
+To use this set be sure to have installed 'angular-oauth2-oidc' dependency.
+
+## Directives
+
+This section outlines the custom directives provided by the Quang Auth.
+
+### QuangIsAuthenticatedDirective
+
+This directive shows content only after user login.
+
+To use it import [QuangIsAuthenticatedDirective](./directives/is-authenticated.directive.ts) and put it in your
+template.
+
+<h4 style="color:#657ED4">@example</h4>
+
+```
+<ng-container *quangIsAuthenticated>
+    your HTML content here
+</ng-container>
+```
+
+### QuangIsNotAuthenticatedDirective
+
+This directive shows content only if user is not authenticated.
+
+To use it import [QuangIsNotAuthenticatedDirective](./directives/is-not-authenticated.directive.ts) and put it in your
+template.
+
+<h4 style="color:#657ED4">@example</h4>
+
+```
+<ng-container *quangIsNotAuthenticated>
+    your HTML content here
+</ng-container>
+```
+
+### QuangHasEveryRoleDirective
+
+This directive shows content only if user is not authenticated.
+
+To use it import [QuangHasEveryRoleDirective](./directives/has-every-role.directive.ts) and put it in your template.
+
+<h4 style="color:#657ED4">@example</h4>
+
+```
+<div *quangHasEveryRole="['admin', 'editor']">
+    This content will only be visible to users with 'admin' and 'editor' roles.
+</div>
+```
+
+### QuangHasAtLeastOneRoleDirective
+
+This directive shows content only if user is not authenticated.
+
+To use it import [QuangHasAtLeastOneRoleDirective](./directives/has-at-least-one-role.directive.ts) and put it in your
+template.
+
+<h4 style="color:#657ED4">@example</h4>
+
+```
+<div *quangHasAtLeastOneRole="['admin', 'editor']">
+    This content will only be visible to users with 'admin' or 'editor' roles.
+</div>
+```
+
+## Guards
+
+Guards are used to control access to routes in your Angular application. This section details the available guards for
+protecting routes based on user authentication status.
+
+### IsAllowedGuard
+
+The `quangIsAllowedGuardFactory` allows access to route only if user has definited roles.
+
+[quangIsAllowedGuardFactory](./guards/is-allowed.guard.ts)
+
+<h4 style="color:#657ED4">@example</h4>
+
+```
+export const routes: Routes = [
+  {
+    path: '',
+    redirectTo: 'components-test',
+    pathMatch: 'full',
+    canActivate: [quangIsAllowedGuardFactory(['adming', 'editor'], 'every')]
+  },
+  {
+    path: '**',
+    redirectTo: 'components-test',
+  },
+]
+```
+
+### IsAuthenticatedGuard
+
+The `quangIsAuthenticatedGuard` allows access to route only if user is authenticated.
+
+[quangIsAuthenticatedGuard](./guards/is-authenticated.guard.ts)
+
+<h4 style="color:#657ED4">@example</h4>
+
+```
+export const routes: Routes = [
+  {
+    path: '',
+    redirectTo: 'components-test',
+    pathMatch: 'full',
+    canActivate: [quangIsAuthenticatedGuard],
+  },
+  {
+    path: '**',
+    redirectTo: 'components-test',
+  },
+]
+```
+
+### Mobile
+
+This section covers the mobile-specific functionalities offered by the Quang Auth service.
+
+Function `withMobileAuth()` in [mobile-auth-feature.ts](./mobile/mobile-auth-feature.ts) return if auth is managed in a
+mobile app.
+
+### Auth Providers
+
+[auth-providers.ts](./auth-providers.ts)
+
+This section describes the configuration options for the Quang Auth service. It details the providers that need to be
+registered in your Angular application's configuration (app.config.ts) to enable authentication functionality.
+
+### Auth Service
+
+[`QuangAuthService`](./auth.service.ts) provides a set of functions, models, and interfaces for interacting with the
+authentication system. This section documents the available methods, data structures, and contracts for using the Auth
+service effectively.
+
+The service DOES NOT handle automatically the roles for the user. It's needed to call the `addRoles()` method to add
+roles to the user after login.
+
+```
+userSubscription$ = toObservable(this.authService.user)
+    .pipe(
+        takeUntilDestroyed(),
+        tap((u) => console.log('u ---->', u)),
+        map((user) => user?.['info'].realm_access.roles as string[]), // customize with your actual handling of roles
+        filter((roles) => roles.length > 0),
+        tap((roles) => {
+            this.authService.addRoles(roles)
+        })
+    )
+.subscribe()
+```

package/auth/auth-providers.d.ts

@@ -0,0 +1,39 @@
+import { EnvironmentProviders, Provider } from '@angular/core';
+import { type QuangFeature, QuangFeatureKind } from 'quang';
+import { type QuangAuthConfig } from './auth.service';
+export declare function provideAuth(authConfig?: QuangAuthConfig, ...features: QuangAuthFeatures[]): EnvironmentProviders;
+export declare function withAuth(authConfig?: QuangAuthConfig, ...features: QuangAuthFeatures[]): QuangFeature<QuangFeatureKind.LoaderFeature>;
+/**
+ * Helper type to represent a QuangAuth feature.
+ *
+ * @publicApi
+ */
+export interface QuangAuthFeature<FeatureKind extends QuangAuthFeatureKind> {
+    ɵkind: FeatureKind;
+    ɵproviders: (Provider | EnvironmentProviders)[];
+}
+/**
+ * Helper function to create an object that represents a QuangAuth feature.
+ */
+export declare function quangAuthFeature<FeatureKind extends QuangAuthFeatureKind>(kind: FeatureKind, providers: (Provider | EnvironmentProviders)[]): QuangAuthFeature<FeatureKind>;
+/**
+ * A type alias that represents all QuangAuth features available for use with `provideAuth`.
+ * Features can be enabled by adding special functions to the `provideAuth` call.
+ * See documentation for each symbol to find corresponding function name. See also `provideAuth`
+ * documentation on how to use those functions.
+ *
+ * @see {@link provideAuth}
+ *
+ * @publicApi
+ */
+export type QuangAuthFeatures = QuangAuthFeature<QuangAuthFeatureKind>;
+/**
+ * The list of features as an enum to uniquely type each feature.
+ */
+export declare const enum QuangAuthFeatureKind {
+    MobileAuthFeature = 0,
+    SessionStorageFeature = 1,
+    LocalStorageFeature = 2,
+    MemoryStorageFeature = 3,
+    LogoutOnErrorFeature = 4
+}

package/auth/auth.service.d.ts

@@ -0,0 +1,52 @@
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { AuthConfig } from 'angular-oauth2-oidc';
+import * as i0 from "@angular/core";
+export declare const AUTH_CONFIG: InjectionToken<QuangAuthConfig | undefined>;
+export interface QuangAuthConfig extends AuthConfig {
+    autoLogin: boolean;
+    sendAccessToken: boolean;
+    urlsToSendToken: string[];
+    revokeTokensOnLogout?: boolean;
+    getUserProfileOnLoginSuccess?: boolean;
+    useSilentRefresh: boolean;
+}
+export declare function provideQuangAuthConfig(authConfig?: QuangAuthConfig): EnvironmentProviders;
+export declare const OPEN_URI: InjectionToken<(uri: string) => void | undefined>;
+export declare function provideOpenURI(openURI: (uri: string) => void | undefined): EnvironmentProviders;
+interface TokenStatus {
+    accessToken: string | null;
+    accessTokenExpiresAt: number | null;
+    idToken: string | null;
+    idTokenExpiresAt: number | null;
+    refreshToken: string | null;
+}
+export declare class QuangAuthService {
+    private config;
+    logLevel: "normal" | "verbose" | null;
+    private oAuthService;
+    private state;
+    loginChecked: import("@ngrx/signals/src/deep-signal").Signal<boolean>;
+    isAuthenticated: import("@angular/core").Signal<boolean>;
+    authenticationError: import("@ngrx/signals/src/deep-signal").Signal<boolean>;
+    tokenStatus: import("@ngrx/signals").DeepSignal<TokenStatus>;
+    roles: import("@ngrx/signals/src/deep-signal").Signal<Set<string>>;
+    user: import("@ngrx/signals/src/deep-signal").Signal<Record<string, any> | null>;
+    constructor();
+    init(): Promise<void>;
+    checkForAuthentication(forceRefresh?: boolean): Promise<boolean | undefined>;
+    private refreshAuth;
+    login(): void;
+    logout(): Promise<void>;
+    private loginError;
+    getUserProfile(): Promise<void>;
+    private setTokens;
+    waitForLoginCheck(): Promise<void>;
+    getAuthResult(): Promise<boolean>;
+    addRoles(rolesToAdd: string[]): void;
+    removeRoles(rolesToRemove: string[]): void;
+    hasEveryRole(roles: string[]): boolean;
+    hasAtLeastOneRole(roles: string[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QuangAuthService>;
+}
+export {};

package/auth/directives/has-at-least-one-role.directive.d.ts

@@ -0,0 +1,26 @@
+import { ChangeDetectorRef, EmbeddedViewRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import { QuangAuthService } from '../auth.service';
+import * as i0 from "@angular/core";
+/**
+ * This directive conditionally renders the associated template if the authenticated user
+ * has at least one of the specified roles. By using the `QuangAuthService.hasAtLeastOneRole()` method it checks the user's roles against
+ * the required roles provided through the `quangHasAtLeastOneRole` directive.
+ *
+ * @example
+ * <div *quangHasAtLeastOneRole="['admin', 'editor']">
+ *   This content will only be visible to users with 'admin' or 'editor' roles.
+ * </div>
+ */
+export declare class QuangHasAtLeastOneRoleDirective {
+    logLevel: "normal" | "verbose" | null;
+    targetRoles: import("@angular/core").InputSignal<string[]>;
+    viewContainerRef: ViewContainerRef;
+    embeddedViewRef: EmbeddedViewRef<unknown> | null;
+    templateRef: TemplateRef<any>;
+    authService: QuangAuthService;
+    takeUntilDestroyed: import("rxjs").MonoTypeOperatorFunction<unknown>;
+    changeDetectorRef: ChangeDetectorRef;
+    hideViewIfNotAllowed: import("@angular/core").EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangHasAtLeastOneRoleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QuangHasAtLeastOneRoleDirective, "[quangHasAtLeastOneRole]", never, { "targetRoles": { "alias": "quangHasAtLeastOneRole"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/auth/directives/has-every-role.directive.d.ts

@@ -0,0 +1,26 @@
+import { ChangeDetectorRef, EmbeddedViewRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import { QuangAuthService } from '../auth.service';
+import * as i0 from "@angular/core";
+/**
+ * This directive conditionally renders the associated template if the authenticated user
+ * has every of the specified roles. By using the `QuangAuthService.hasEveryRole()` method it checks the user's roles against
+ * the required roles provided through the `quangHasEveryRole` required input.
+ *
+ * @example
+ * <div *quangHasEveryRole="['admin', 'editor']">
+ *   This content will only be visible to users with 'admin' and 'editor' roles.
+ * </div>
+ */
+export declare class QuangHasEveryRoleDirective {
+    logLevel: "normal" | "verbose" | null;
+    targetRoles: import("@angular/core").InputSignal<string[]>;
+    viewContainerRef: ViewContainerRef;
+    embeddedViewRef: EmbeddedViewRef<unknown> | null;
+    templateRef: TemplateRef<any>;
+    authService: QuangAuthService;
+    takeUntilDestroyed: import("rxjs").MonoTypeOperatorFunction<unknown>;
+    changeDetectorRef: ChangeDetectorRef;
+    hideViewIfNotAllowed: import("@angular/core").EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangHasEveryRoleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QuangHasEveryRoleDirective, "[quangHasEveryRole]", never, { "targetRoles": { "alias": "quangHasEveryRole"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/auth/directives/is-authenticated.directive.d.ts

@@ -0,0 +1,14 @@
+import { ChangeDetectorRef, EmbeddedViewRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import { QuangAuthService } from '../auth.service';
+import * as i0 from "@angular/core";
+export declare class QuangIsAuthenticatedDirective {
+    viewContainerRef: ViewContainerRef;
+    templateRef: TemplateRef<any>;
+    embeddedViewRef: EmbeddedViewRef<any> | null;
+    authService: QuangAuthService;
+    takeUntilDestroyed: import("rxjs").MonoTypeOperatorFunction<unknown>;
+    changeDetectorRef: ChangeDetectorRef;
+    hideViewIfNotAuthenticated: import("@angular/core").EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangIsAuthenticatedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QuangIsAuthenticatedDirective, "[quangIsAuthenticated]", never, {}, {}, never, never, true, never>;
+}

package/auth/directives/is-not-authenticated.directive.d.ts

@@ -0,0 +1,14 @@
+import { ChangeDetectorRef, EmbeddedViewRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import { QuangAuthService } from '../auth.service';
+import * as i0 from "@angular/core";
+export declare class QuangIsNotAuthenticatedDirective {
+    viewContainerRef: ViewContainerRef;
+    templateRef: TemplateRef<any>;
+    embeddedViewRef: EmbeddedViewRef<any> | null;
+    authService: QuangAuthService;
+    takeUntilDestroyed: import("rxjs").MonoTypeOperatorFunction<unknown>;
+    changeDetectorRef: ChangeDetectorRef;
+    showViewIfNotAuthenticated: import("@angular/core").EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangIsNotAuthenticatedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QuangIsNotAuthenticatedDirective, "[quangIsNotAuthenticated]", never, {}, {}, never, never, true, never>;
+}

package/auth/guards/index.d.ts

@@ -0,0 +1,2 @@
+export * from './is-allowed.guard';
+export * from './is-authenticated.guard';

package/auth/guards/is-allowed.guard.d.ts

@@ -0,0 +1,2 @@
+import type { CanActivateFn } from '@angular/router';
+export declare const quangIsAllowedGuardFactory: (roles: string[], behavior: "every" | "atLeastOne") => CanActivateFn;

package/auth/guards/is-authenticated.guard.d.ts

@@ -0,0 +1,2 @@
+import type { CanActivateFn } from '@angular/router';
+export declare const quangIsAuthenticatedGuard: CanActivateFn;

package/auth/index.d.ts

@@ -0,0 +1,9 @@
+export * from './auth-providers';
+export * from './auth.service';
+export * from './directives/has-at-least-one-role.directive';
+export * from './directives/has-every-role.directive';
+export * from './directives/is-authenticated.directive';
+export * from './directives/is-not-authenticated.directive';
+export * from './guards';
+export * from './logout-on-error.interceptor';
+export * from './token-storage';

package/auth/logout-on-error.interceptor.d.ts

@@ -0,0 +1,9 @@
+import { HttpInterceptorFn } from '@angular/common/http';
+import { InjectionToken } from '@angular/core';
+import { UrlData } from 'quang/shared';
+import { QuangAuthFeature, QuangAuthFeatureKind } from './auth-providers';
+export declare const LOGOUT_RETRIES: InjectionToken<number>;
+export declare const LOGOUT_STATUSES: InjectionToken<number[]>;
+export declare const LOGOUT_EXCLUDED_URLS: InjectionToken<UrlData[]>;
+export declare const logoutOnErrorInterceptor: HttpInterceptorFn;
+export declare function withLogoutOnError(excludedUrls?: UrlData[], statuses?: number[], retries?: number): QuangAuthFeature<QuangAuthFeatureKind.LogoutOnErrorFeature>;

package/auth/mobile/index.d.ts

@@ -0,0 +1 @@
+export * from './mobile-auth-feature';

package/auth/mobile/mobile-auth-feature.d.ts

@@ -0,0 +1,2 @@
+import { QuangAuthFeature, QuangAuthFeatureKind } from 'quang/auth';
+export declare function withMobileAuth(toolbarColor?: string, presentationStyle?: 'popover' | 'fullscreen'): QuangAuthFeature<QuangAuthFeatureKind.MobileAuthFeature>;

package/auth/token-storage/index.d.ts

@@ -0,0 +1,3 @@
+export * from './local-storage-feature';
+export * from './memory-storage-feature';
+export * from './session-storage-feature';

package/auth/token-storage/local-storage-feature.d.ts

@@ -0,0 +1,2 @@
+import { QuangAuthFeature, QuangAuthFeatureKind } from '../auth-providers';
+export declare function withLocalStorage(): QuangAuthFeature<QuangAuthFeatureKind.LocalStorageFeature>;

package/auth/token-storage/memory-storage-feature.d.ts

@@ -0,0 +1,12 @@
+import { OAuthStorage } from 'angular-oauth2-oidc';
+import { QuangAuthFeature, QuangAuthFeatureKind } from '../auth-providers';
+import * as i0 from "@angular/core";
+export declare class MemoryStorage implements OAuthStorage {
+    private data;
+    getItem(key: string): string;
+    removeItem(key: string): void;
+    setItem(key: string, data: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MemoryStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MemoryStorage>;
+}
+export declare function withMemoryStorage(): QuangAuthFeature<QuangAuthFeatureKind.MemoryStorageFeature>;

package/auth/token-storage/session-storage-feature.d.ts

@@ -0,0 +1,2 @@
+import { QuangAuthFeature, QuangAuthFeatureKind } from '../auth-providers';
+export declare function withSessionStorage(): QuangAuthFeature<QuangAuthFeatureKind.SessionStorageFeature>;

package/components/autocomplete/autocomplete.component.d.ts

@@ -0,0 +1,43 @@
+import { Subject, Subscription } from 'rxjs';
+import { OptionListParentType, QuangBaseComponent, QuangOptionListComponent, SelectOption } from 'quang/components/shared';
+import * as i0 from "@angular/core";
+export declare class QuangAutocompleteComponent extends QuangBaseComponent<string | number> {
+    syncFormWithText: import("@angular/core").InputSignal<boolean>;
+    optionListMaxHeight: import("@angular/core").InputSignal<string>;
+    selectOptions: import("@angular/core").InputSignal<SelectOption[]>;
+    translateValue: import("@angular/core").InputSignal<boolean>;
+    scrollBehaviorOnOpen: import("@angular/core").InputSignal<ScrollBehavior>;
+    optionList: import("@angular/core").Signal<QuangOptionListComponent | undefined>;
+    /**
+     * Only emits the value without saving it in ngControl
+     */
+    emitOnly: import("@angular/core").InputSignal<boolean>;
+    _showOptions: import("@angular/core").WritableSignal<boolean | null>;
+    _inputValue: import("@angular/core").WritableSignal<string>;
+    _optionHideTimeout: import("@angular/core").WritableSignal<any>;
+    inputValue$: Subject<string>;
+    selectOptionsChange: Subscription;
+    _filteredOptions: import("@angular/core").Signal<SelectOption[]>;
+    selectedOption: import("@angular/core").OutputEmitterRef<string | number | null>;
+    searchTextChange: import("@angular/core").OutputEmitterRef<string>;
+    searchTextDebounce: import("@angular/core").InputSignal<number>;
+    internalFilterOptions: import("@angular/core").InputSignal<boolean>;
+    readonly ParentType = OptionListParentType.AUTOCOMPLETE;
+    formValueChange$: Subscription | undefined;
+    constructor();
+    setupFormControl(): void;
+    showOptionVisibility(): void;
+    hideOptionVisibility(skipTimeout?: boolean): void;
+    onChangeInput(value: any): void;
+    filterOptions(value: string): SelectOption[];
+    onChangedHandler(value: string | number): void;
+    onValueChange(value: string | number, hideOptions?: boolean): void;
+    checkInputValue(): void;
+    writeValue(val: string | number): void;
+    onBlurInput(event: FocusEvent): void;
+    onBlurHandler(): void;
+    onBlurOptionList(event: any): void;
+    setInputValue(resetOnMiss?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuangAutocompleteComponent, "quang-autocomplete", never, { "syncFormWithText": { "alias": "syncFormWithText"; "required": false; "isSignal": true; }; "optionListMaxHeight": { "alias": "optionListMaxHeight"; "required": false; "isSignal": true; }; "selectOptions": { "alias": "selectOptions"; "required": true; "isSignal": true; }; "translateValue": { "alias": "translateValue"; "required": false; "isSignal": true; }; "scrollBehaviorOnOpen": { "alias": "scrollBehaviorOnOpen"; "required": false; "isSignal": true; }; "emitOnly": { "alias": "emitOnly"; "required": false; "isSignal": true; }; "searchTextDebounce": { "alias": "searchTextDebounce"; "required": false; "isSignal": true; }; "internalFilterOptions": { "alias": "internalFilterOptions"; "required": false; "isSignal": true; }; }, { "selectedOption": "selectedOption"; "searchTextChange": "searchTextChange"; }, never, never, true, never>;
+}

package/components/autocomplete/index.d.ts

@@ -0,0 +1 @@
+export * from './autocomplete.component';

package/components/checkbox/checkbox.component.d.ts

@@ -0,0 +1,11 @@
+import { QuangBaseComponent } from 'quang/components/shared';
+import * as i0 from "@angular/core";
+export type LabelPosition = 'top' | 'left' | 'right' | 'bottom';
+export declare class QuangCheckboxComponent extends QuangBaseComponent<boolean> {
+    labelPosition: import("@angular/core").InputSignal<LabelPosition>;
+    checkType: import("@angular/core").InputSignal<"checkbox" | "toggle">;
+    removeMargin: import("@angular/core").InputSignal<boolean>;
+    onChangedEventHandler($event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuangCheckboxComponent, "quang-checkbox", never, { "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "checkType": { "alias": "checkType"; "required": true; "isSignal": true; }; "removeMargin": { "alias": "removeMargin"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/checkbox/index.d.ts

@@ -0,0 +1 @@
+export * from './checkbox.component';

package/components/date/date.component.d.ts

@@ -0,0 +1,85 @@
+import { ElementRef } from '@angular/core';
+import AirDatepicker, { AirDatepickerLocale, AirDatepickerOptions, AirDatepickerPosition } from 'air-datepicker';
+import { QuangTranslationService } from 'quang/translation';
+import { QuangBaseComponent } from 'quang/components/shared';
+import * as i0 from "@angular/core";
+export interface DateRange {
+    dateFrom: string | null;
+    dateTo: string | null;
+}
+export type QuangDatepickerOptions = AirDatepickerOptions;
+export declare class QuangDateComponent extends QuangBaseComponent<string | DateRange | null> {
+    /**
+     * Format to use to show on the input field.
+     * The format is based on the standard {@link https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table}
+     * Default: dd/MM/yyyy
+     * @default dd/MM/yyyy
+     */
+    dateFormat: import("@angular/core").InputSignal<string>;
+    /**
+     * Format to use to show on the time inside the input field.
+     * The format is based on the standard {@link https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table}
+     * Default: HH:mm
+     * @default HH:mm
+     */
+    timeFormat: import("@angular/core").InputSignal<string>;
+    /**
+     * Calendar locale, if not provided the component will try to use the one provided in {@link QuangTranslationService}
+     * if the language is not set in {@link QuangTranslationService} it will use the browser language
+     * Use this parameter only to override default behavior
+     */
+    activeLanguageOverride: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * If true enable the timepicker inside the calendar
+     */
+    timepicker: import("@angular/core").InputSignal<boolean>;
+    /**
+     * The message to show inside the input if the date is invalid
+     */
+    invalidDateMessage: import("@angular/core").InputSignal<string>;
+    showOnlyTimepicker: import("@angular/core").InputSignal<boolean>;
+    minHour: import("@angular/core").InputSignal<number>;
+    maxHour: import("@angular/core").InputSignal<number>;
+    minMinute: import("@angular/core").InputSignal<number>;
+    maxMinute: import("@angular/core").InputSignal<number>;
+    minDate: import("@angular/core").InputSignal<Date | undefined>;
+    maxDate: import("@angular/core").InputSignal<Date | undefined>;
+    showInline: import("@angular/core").InputSignal<boolean>;
+    calendarClasses: import("@angular/core").InputSignal<string>;
+    buttonClass: import("@angular/core").InputSignal<string>;
+    datepickerOptions: import("@angular/core").InputSignal<QuangDatepickerOptions | undefined>;
+    _inputForDate: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    contentTemplate: import("@angular/core").Signal<ElementRef<any>>;
+    hasNoContent: import("@angular/core").Signal<boolean>;
+    _quangTranslationService: import("@angular/core").WritableSignal<QuangTranslationService | undefined>;
+    _quangTranslationActiveLang: import("@angular/core").Signal<string | null>;
+    multipleDatesSeparator: import("@angular/core").InputSignal<string>;
+    rangeSelection: import("@angular/core").InputSignal<boolean>;
+    _activeLanguage: import("@angular/core").Signal<string | null | undefined>;
+    _airDatepickerInstance: import("@angular/core").WritableSignal<AirDatepicker<HTMLInputElement> | undefined>;
+    searchTextDebounce: import("@angular/core").InputSignal<number>;
+    targetPosition: import("@angular/core").WritableSignal<AirDatepickerPosition>;
+    _generateAirDatepickerEffect: import("@angular/core").EffectRef;
+    valueFormat: import("@angular/core").Signal<string>;
+    inputValueString: import("@angular/core").Signal<string>;
+    constructor();
+    showTimepicker: import("@angular/core").Signal<boolean>;
+    isMouseInsideCalendar: import("@angular/core").WritableSignal<boolean>;
+    isMouseOutsideCalendar: import("@angular/core").Signal<boolean>;
+    setupCalendar(): void;
+    onChangeText($event: Event): void;
+    onBlurHandler(): void;
+    setupInputStringToDate(value: string): Date;
+    onChangedHandler(value: string | DateRange | null): void;
+    onHideCalendar(): void;
+    formatDate(val: string | DateRange | null): string;
+    openDatePicker(): void;
+    interceptInputInteraction($event: Event): void;
+    getLocale(): AirDatepickerLocale;
+    onCancel(): void;
+    private dateToUtc;
+    private setCalendarPosition;
+    private setupTimepicker;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuangDateComponent, "quang-date", never, { "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "activeLanguageOverride": { "alias": "activeLanguageOverride"; "required": false; "isSignal": true; }; "timepicker": { "alias": "timepicker"; "required": false; "isSignal": true; }; "invalidDateMessage": { "alias": "invalidDateMessage"; "required": false; "isSignal": true; }; "showOnlyTimepicker": { "alias": "showOnlyTimepicker"; "required": false; "isSignal": true; }; "minHour": { "alias": "minHour"; "required": false; "isSignal": true; }; "maxHour": { "alias": "maxHour"; "required": false; "isSignal": true; }; "minMinute": { "alias": "minMinute"; "required": false; "isSignal": true; }; "maxMinute": { "alias": "maxMinute"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "showInline": { "alias": "showInline"; "required": false; "isSignal": true; }; "calendarClasses": { "alias": "calendarClasses"; "required": false; "isSignal": true; }; "buttonClass": { "alias": "buttonClass"; "required": false; "isSignal": true; }; "datepickerOptions": { "alias": "datepickerOptions"; "required": false; "isSignal": true; }; "multipleDatesSeparator": { "alias": "multipleDatesSeparator"; "required": false; "isSignal": true; }; "rangeSelection": { "alias": "rangeSelection"; "required": false; "isSignal": true; }; "searchTextDebounce": { "alias": "searchTextDebounce"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/components/date/global-date.component.scss

@@ -0,0 +1 @@
+@import 'air-datepicker/air-datepicker.css';

package/components/date/index.d.ts

@@ -0,0 +1 @@
+export * from './date.component';

package/components/input/index.d.ts

@@ -0,0 +1 @@
+export * from './input.component';

package/components/input/input.component.d.ts

@@ -0,0 +1,15 @@
+import { QuangBaseComponent } from 'quang/components/shared';
+import * as i0 from "@angular/core";
+export type InputType = 'text' | 'textarea' | 'password' | 'email' | 'number' | 'url' | 'search' | 'tel' | 'color';
+export declare class QuangInputComponent extends QuangBaseComponent<string | number> {
+    componentType: import("@angular/core").InputSignal<InputType>;
+    maxLengthText: import("@angular/core").InputSignal<number | null>;
+    minLengthText: import("@angular/core").InputSignal<number | null>;
+    minNumber: import("@angular/core").InputSignal<number | undefined>;
+    maxNumber: import("@angular/core").InputSignal<number | undefined>;
+    componentStep: import("@angular/core").InputSignal<number>;
+    resizable: import("@angular/core").InputSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuangInputComponent, "quang-input", never, { "componentType": { "alias": "componentType"; "required": true; "isSignal": true; }; "maxLengthText": { "alias": "maxLengthText"; "required": false; "isSignal": true; }; "minLengthText": { "alias": "minLengthText"; "required": false; "isSignal": true; }; "minNumber": { "alias": "minNumber"; "required": false; "isSignal": true; }; "maxNumber": { "alias": "maxNumber"; "required": false; "isSignal": true; }; "componentStep": { "alias": "componentStep"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/paginator/index.d.ts

@@ -0,0 +1,5 @@
+export * from './paginator-language.service';
+export * from './paginator.component';
+export * from './paginator.module';
+export * from './paginator.service';
+export * from './paginatorIntl';

package/components/paginator/paginator-language.service.d.ts

@@ -0,0 +1,10 @@
+import { TranslocoService } from '@jsverse/transloco';
+import { PaginatorIntl } from './paginatorIntl';
+import * as i0 from "@angular/core";
+export declare class QuangPaginatorLanguageService extends PaginatorIntl {
+    private readonly transloco;
+    constructor(transloco: TranslocoService);
+    getAndInitTranslations(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuangPaginatorLanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QuangPaginatorLanguageService>;
+}