@lucca-front/ng 19.3.3 → 20.0.0

package/comment/index.d.ts

@@ -1,5 +1,46 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/comment" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as _lucca_front_ng_core from '@lucca-front/ng/core';
+import { PortalContent } from '@lucca-front/ng/core';
+
+declare class CommentComponent {
+    #private;
+    noAvatar: _angular_core.Signal<boolean>;
+    avatar: _angular_core.Signal<_angular_core.TemplateRef<unknown>>;
+    authorName: _angular_core.Signal<_lucca_front_ng_core.PortalContent>;
+    size: _angular_core.Signal<"S" | "M">;
+    date: _angular_core.InputSignal<Date>;
+    content: _angular_core.InputSignal<string>;
+    contentIsHTML: _angular_core.Signal<boolean>;
+    dateDisplay: _angular_core.Signal<string>;
+    role: _angular_core.Signal<string>;
+    get roleAttr(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommentComponent, "lu-comment", never, { "date": { "alias": "date"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class CommentBlockComponent {
+    #private;
+    compact: boolean;
+    small: boolean;
+    chatAnswer: boolean;
+    comments: _angular_core.Signal<readonly CommentComponent[]>;
+    authorName: _angular_core.InputSignal<PortalContent>;
+    avatar: _angular_core.InputSignal<TemplateRef<unknown>>;
+    size: _angular_core.InputSignal<"S" | "M">;
+    noAvatar: _angular_core.Signal<boolean>;
+    isSingleComment: _angular_core.Signal<boolean>;
+    role: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommentBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommentBlockComponent, "lu-comment-block", never, { "compact": { "alias": "compact"; "required": false; }; "small": { "alias": "small"; "required": false; }; "chatAnswer": { "alias": "chatAnswer"; "required": false; }; "authorName": { "alias": "authorName"; "required": false; "isSignal": true; }; "avatar": { "alias": "avatar"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["comments"], ["*"], true, never>;
+    static ngAcceptInputType_compact: unknown;
+    static ngAcceptInputType_small: unknown;
+    static ngAcceptInputType_chatAnswer: unknown;
+}
+
+declare class CommentChatComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommentChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommentChatComponent, "lu-comment-chat", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { CommentBlockComponent, CommentChatComponent, CommentComponent };

package/core/index.d.ts

@@ -1,5 +1,235 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, TemplateRef, Type, OnChanges, OnDestroy, SimpleChanges, Signal, CreateEffectOptions, PipeTransform } from '@angular/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * Extracts the values of an enum as a union type.
+ *
+ * @example
+ * ```ts
+ * enum ExampleEnum {
+ *    A = 'a',
+ *    B = 'b',
+ * }
+ *
+ * type ExampleEnumValue = EnumValue<typeof ExampleEnum>; // Same as 'a' | 'b'
+ * ```
  */
-/// <amd-module name="@lucca-front/ng/core" />
-export * from './public-api';
+type EnumValue<T> = `${T[keyof T] & string}`;
+
+/**
+ * Available CSS palettes
+ */
+type Palette = 'success' | 'warning' | 'error' | 'product' | 'brand' | 'neutral' | 'none' | 'primary' | 'grey';
+type DecorativePalette = 'kiwi' | 'lime' | 'cucumber' | 'mint' | 'glacier' | 'lagoon' | 'blueberry' | 'lavender' | 'grape' | 'watermelon' | 'pumpkin' | 'pineapple';
+
+declare enum ELuDateGranularity {
+    day = "day",
+    month = "month",
+    year = "year",
+    decade = "decade"
+}
+type LuDateGranularity = EnumValue<ELuDateGranularity>;
+
+interface ILuDateAdapter<D> {
+    forge(year: number, month: number, date: number): D;
+    forgeToday(): D;
+    forgeInvalid(): D;
+    isValid(d: D): boolean;
+    compare(a: D, b: D, granularity: LuDateGranularity): number;
+    isParsable(text: string, granularity?: LuDateGranularity): boolean;
+    parse(text: string, granularity?: LuDateGranularity): D;
+    format(d: D, format: string): string;
+    clone(d: D): D;
+    getYear(d: D): number;
+    getMonth(d: D): number;
+    getDate(d: D): number;
+    getDay(d: D): number;
+    add(d: D, count: number, granularity: LuDateGranularity): D;
+}
+
+declare abstract class ALuDateAdapter<D> implements ILuDateAdapter<D> {
+    abstract forge(year: number, month: number, date: number): D;
+    abstract forgeToday(): D;
+    abstract forgeInvalid(): D;
+    abstract isValid(d: D): boolean;
+    compare(a: D, b: D, granularity: LuDateGranularity): number;
+    abstract isParsable(text: string, granularity?: LuDateGranularity): boolean;
+    abstract parse(text: string, granularity?: LuDateGranularity): D;
+    abstract format(d: D, format: string): string;
+    abstract clone(d: D): D;
+    abstract getYear(d: D): number;
+    abstract getMonth(d: D): number;
+    abstract getDate(d: D): number;
+    abstract getDay(d: D): number;
+    abstract add(d: D, count: number, granularity: LuDateGranularity): D;
+}
+
+interface ILuNativeDateAdapterOptions {
+    useUtc?: boolean;
+}
+declare const luDefaultNativeDateAdapterOptions: ILuNativeDateAdapterOptions;
+declare const LU_NATIVE_DATE_ADAPTER_OPTIONS: InjectionToken<ILuNativeDateAdapterOptions>;
+
+declare class LuNativeDateAdapter extends ALuDateAdapter<Date> implements ILuDateAdapter<Date> {
+    private _locale;
+    private _options;
+    private _regex;
+    private _order;
+    constructor(_locale: string, _options: ILuNativeDateAdapterOptions);
+    private initOrder;
+    private extract;
+    isParsable(text: string, granularity?: LuDateGranularity): boolean;
+    parse(text: string, granularity?: LuDateGranularity): Date;
+    format(d: Date, format: string): string;
+    forge(year: number, month: number, date: number): Date;
+    forgeToday(): Date;
+    forgeInvalid(): Date;
+    isValid(d: Date): boolean;
+    clone(d: Date): Date;
+    getYear(d: Date): number;
+    getMonth(d: Date): number;
+    getDate(d: Date): number;
+    getDay(d: Date): number;
+    add(d: Date, count: number, granularity: LuDateGranularity): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuNativeDateAdapter, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuNativeDateAdapter>;
+}
+
+/** bind to a string with iso 26001 format YYYY-MM-DD */
+declare class LuStringDateAdapter extends ALuDateAdapter<string> implements ILuDateAdapter<string> {
+    private _locale;
+    private _nativeAdapter;
+    constructor(_locale: string);
+    forge(year: number, month: number, date: number): string;
+    forgeToday(): string;
+    forgeInvalid(): string;
+    isValid(d: string): boolean;
+    compare(a: string, b: string, granularity: LuDateGranularity): number;
+    isParsable(text: string): boolean;
+    parse(text: string, granularity: LuDateGranularity): string;
+    format(d: string, format: string): string;
+    clone(d: string): string;
+    getYear(d: string): number;
+    getMonth(d: string): number;
+    getDate(d: string): number;
+    getDay(d: string): number;
+    add(d: string, count: number, granularity: LuDateGranularity): string;
+    protected stringToDate(s: string): Date;
+    protected dateToString(d: Date): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuStringDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuStringDateAdapter>;
+}
+
+interface ILuOnCloseSubscriber {
+    onClose(): void;
+}
+declare abstract class ALuOnCloseSubscriber implements ILuOnCloseSubscriber {
+    abstract onClose(): void;
+}
+
+interface ILuOnOpenSubscriber {
+    onOpen(): void;
+}
+declare abstract class ALuOnOpenSubscriber implements ILuOnOpenSubscriber {
+    abstract onOpen(): void;
+}
+
+interface ILuOnScrollBottomSubscriber {
+    onScrollBottom(): void;
+}
+declare abstract class ALuOnScrollBottomSubscriber implements ILuOnScrollBottomSubscriber {
+    abstract onScrollBottom(): void;
+}
+
+interface ILuGroup<TItem, TKey> {
+    key: TKey;
+    items: TItem[];
+}
+
+declare function generateId(): string;
+
+declare const isNil: <T>(value: T | null | undefined) => value is null | undefined;
+declare const isNotNil: <T>(value: T) => value is NonNullable<T>;
+
+type PortalContent<T = unknown> = string | TemplateRef<T> | Type<unknown>;
+declare const PORTAL_CONTEXT: InjectionToken<unknown>;
+
+declare class PortalDirective<T = unknown> implements OnChanges, OnDestroy {
+    private viewContainerRef;
+    private renderer;
+    private templateRef;
+    private injector;
+    luPortal: PortalContent<T>;
+    luPortalContext: T | null;
+    private createdTextElement;
+    private embeddedViewRef?;
+    private componentRef?;
+    private render;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private renderText;
+    private destroyRenderedText;
+    /**
+     * Embeded view context should not be overwritten, but updated.
+     * @see https://github.com/angular/angular/pull/51887
+     */
+    private updateEmbeddedViewContext;
+    static ngTemplateContextGuard<T>(_dir: PortalDirective<T>, ctx: unknown): ctx is void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PortalDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalDirective<any>, "[luPortal]", never, { "luPortal": { "alias": "luPortal"; "required": true; }; "luPortalContext": { "alias": "luPortalContext"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type EffectWithDepsValues<T> = T extends readonly unknown[] ? TupleOfSignalValues<T> : [RecordOfSignalValues<T>];
+type TupleOfSignalValues<T> = T extends readonly [Signal<infer U>, ...infer R] ? [U, ...TupleOfSignalValues<R>] : [];
+type RecordOfSignalValues<T> = {
+    [K in keyof T]: T[K] extends Signal<infer U> ? U : never;
+};
+type EffectWithDepsInput = ReadonlyArray<Signal<unknown>> | Record<string, Signal<unknown>>;
+/**
+ * Effect peut être dangereux car l'action accomplie peut elle-même déclencher des écritures dans des signaux.
+ * C'est une mauvaise pratique, interdite par défaut par Angular.
+ * La plupars du temps, seule la lecture des signaux est intéressante à tracker, pas les actions qui en découlent.
+ */
+declare function ɵeffectWithDeps<const T extends EffectWithDepsInput>(dependencies: T, action: (...values: EffectWithDepsValues<T>) => unknown, options?: CreateEffectOptions): void;
+
+type LuClassSupportedTypes = string | string[] | Set<string> | {
+    [klass: string]: boolean;
+};
+declare class LuClass {
+    #private;
+    setState(value: LuClassSupportedTypes): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuClass, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuClass>;
+}
+
+/**
+ * @deprecated use `LuTranslation` instead.
+ */
+interface ILuTranslation<T> {
+    en: T;
+    fr: T;
+    'en-GB'?: T;
+    'en-US'?: T;
+    es?: T;
+    de?: T;
+    pt?: T;
+}
+type LuTranslation<T> = Record<string, T>;
+
+declare function getIntl<T>(translationsToken: InjectionToken<LuTranslation<T>> | InjectionToken<ILuTranslation<T>>): T;
+
+declare class IntlParamsPipe implements PipeTransform {
+    #private;
+    transform(value: string, args: Record<string, string | number>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntlParamsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IntlParamsPipe, "intlParams", true>;
+}
+
+interface ILuTree<T> {
+    value: T;
+    children: ILuTree<T>[];
+    disabled?: boolean;
+}
+
+export { ALuDateAdapter, ALuOnCloseSubscriber, ALuOnOpenSubscriber, ALuOnScrollBottomSubscriber, ELuDateGranularity, IntlParamsPipe, LU_NATIVE_DATE_ADAPTER_OPTIONS, LuClass, LuNativeDateAdapter, LuStringDateAdapter, PORTAL_CONTEXT, PortalDirective, generateId, getIntl, isNil, isNotNil, luDefaultNativeDateAdapterOptions, ɵeffectWithDeps };
+export type { DecorativePalette, EnumValue, ILuDateAdapter, ILuGroup, ILuNativeDateAdapterOptions, ILuOnCloseSubscriber, ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber, ILuTranslation, ILuTree, LuDateGranularity, LuTranslation, Palette, PortalContent };

package/core-select/api/index.d.ts

@@ -1,5 +1,80 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/core-select/api" />
-export * from './public-api';
+import { HttpClient } from '@angular/common/http';
+import { ILuApiItem } from '@lucca-front/ng/api';
+import { ALuSelectInputComponent, LuOptionComparer, CoreSelectApiTotalCountProvider } from '@lucca-front/ng/core-select';
+import { Subject, Observable, ReplaySubject, BehaviorSubject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit } from '@angular/core';
+
+declare const LU_SELECT_MAGIC_PAGE_SIZE = 20;
+declare abstract class ALuCoreSelectApiDirective<TOption, TParams = Record<string, string | number | boolean>> implements OnDestroy, OnInit {
+    protected destroy$: Subject<void>;
+    protected pageSize: number;
+    protected debounceDuration: number;
+    select: ALuSelectInputComponent<TOption, unknown>;
+    protected page$: Observable<number>;
+    protected clue$: Observable<string>;
+    /**
+     * Create an object that will be used as params for the api call
+     */
+    protected abstract params$: Observable<TParams>;
+    /**
+     * Compare two options to know if they are the same. For example, compare by id or by JSON
+     */
+    protected optionComparer: LuOptionComparer<TOption>;
+    /**
+     * Return a unique key to identify the option in for-of loops
+     */
+    protected abstract optionKey: (option: TOption) => unknown;
+    /**
+     * Return the options for the given params and page
+     */
+    protected abstract getOptions(params: TParams, page: number): Observable<TOption[]>;
+    ngOnInit(): void;
+    protected buildOptions(): Observable<TOption[]>;
+    protected getOptionsPage(params: TParams, page: number): Observable<{
+        items: TOption[];
+        isLastPage: boolean;
+    }>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ALuCoreSelectApiDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuCoreSelectApiDirective<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class LuCoreSelectApiV3Directive<T extends ILuApiItem> extends ALuCoreSelectApiDirective<T> implements CoreSelectApiTotalCountProvider {
+    set apiV3(value: string);
+    set fields(value: string);
+    set orderBy(value: string | null);
+    set filters(value: Record<string, string | number | boolean>);
+    protected url$: ReplaySubject<string>;
+    protected fields$: BehaviorSubject<string>;
+    protected orderBy$: BehaviorSubject<string>;
+    protected filters$: BehaviorSubject<Record<string, string | number | boolean>>;
+    protected httpClient: HttpClient;
+    protected params$: Observable<{
+        name?: string;
+        orderBy?: string;
+        fields?: string;
+    }>;
+    totalCount$: Observable<number>;
+    protected getOptions(params: Record<string, string | number | boolean>, page: number): Observable<T[]>;
+    protected optionKey: (option: T) => number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuCoreSelectApiV3Directive<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuCoreSelectApiV3Directive<any>, "lu-simple-select[apiV3],lu-multi-select[apiV3]", never, { "apiV3": { "alias": "apiV3"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LuCoreSelectApiV4Directive<T extends ILuApiItem> extends ALuCoreSelectApiDirective<T> implements CoreSelectApiTotalCountProvider {
+    apiV4: i0.ModelSignal<string>;
+    sort: i0.InputSignal<string>;
+    filters: i0.InputSignal<Record<string, string | number | boolean>>;
+    searchDelimiter: i0.InputSignal<string>;
+    protected httpClient: HttpClient;
+    protected clue: i0.Signal<string>;
+    protected params$: Observable<Record<string, string | number | boolean>>;
+    totalCount$: Observable<number>;
+    protected getOptions(params: Record<string, string | number | boolean>, page: number): Observable<T[]>;
+    protected optionKey: (option: T) => number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuCoreSelectApiV4Directive<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuCoreSelectApiV4Directive<any>, "lu-simple-select[apiV4],lu-multi-select[apiV4]", never, { "apiV4": { "alias": "apiV4"; "required": true; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "searchDelimiter": { "alias": "searchDelimiter"; "required": false; "isSignal": true; }; }, { "apiV4": "apiV4Change"; }, never, never, true, never>;
+}
+
+export { ALuCoreSelectApiDirective, LU_SELECT_MAGIC_PAGE_SIZE, LuCoreSelectApiV3Directive, LuCoreSelectApiV4Directive };

package/core-select/establishment/index.d.ts

@@ -1,5 +1,52 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/core-select/establishment" />
-export * from './public-api';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { CoreSelectApiTotalCountProvider } from '@lucca-front/ng/core-select';
+import { ALuCoreSelectApiDirective } from '@lucca-front/ng/core-select/api';
+import { ILuApiItem } from '@lucca-front/ng/api';
+
+declare class EstablishmentGroupingService {
+    protected http: HttpClient;
+    protected establishmentsUrl: string;
+    protected legalUnitsUrl: string;
+    protected countParams: HttpParams;
+    protected establishmentsCount$: rxjs.Observable<number>;
+    protected legalUnitsCount$: rxjs.Observable<number>;
+    useGrouping$: rxjs.Observable<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EstablishmentGroupingService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EstablishmentGroupingService>;
+}
+
+interface LuCoreSelectLegalUnit extends ILuApiItem {
+    countryId: number;
+}
+interface LuCoreSelectEstablishment extends ILuApiItem {
+    code: string;
+    legalUnitId: number;
+    legalUnit: LuCoreSelectLegalUnit;
+}
+
+declare class LuCoreSelectEstablishmentsDirective<T extends LuCoreSelectEstablishment = LuCoreSelectEstablishment> extends ALuCoreSelectApiDirective<T> implements OnInit, CoreSelectApiTotalCountProvider {
+    #private;
+    protected httpClient: HttpClient;
+    url: _angular_core.InputSignal<string>;
+    filters: _angular_core.InputSignal<Record<string, string | number | boolean>>;
+    operationIds: _angular_core.InputSignal<readonly number[]>;
+    uniqueOperationIds: _angular_core.InputSignal<readonly number[]>;
+    appInstanceId: _angular_core.InputSignal<number>;
+    searchDelimiter: _angular_core.InputSignal<string>;
+    protected clue: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    protected initGrouping(): void;
+    protected getOptions(params: Record<string, string | number | boolean> | null, page: number): Observable<T[]>;
+    protected params$: Observable<Record<string, string | number | boolean>>;
+    totalCount$: Observable<number>;
+    protected optionKey: (option: T) => number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectEstablishmentsDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectEstablishmentsDirective<any>, "lu-simple-select[establishments],lu-multi-select[establishments]", ["luEstablishments"], { "url": { "alias": "url"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "operationIds": { "alias": "operationIds"; "required": false; "isSignal": true; }; "uniqueOperationIds": { "alias": "uniqueOperationIds"; "required": false; "isSignal": true; }; "appInstanceId": { "alias": "appInstanceId"; "required": false; "isSignal": true; }; "searchDelimiter": { "alias": "searchDelimiter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { EstablishmentGroupingService, LuCoreSelectEstablishmentsDirective };
+export type { LuCoreSelectEstablishment, LuCoreSelectLegalUnit };