@dsivd/prestations-ng 19.2.0-beta.8 → 19.2.0-beta.9

package/package.json

@@ -39,7 +39,7 @@
   "ng-update": {
     "migrations": "./schematics/migration-collection.json"
   },
-  "version": "19.2.0-beta.8",
+  "version": "19.2.0-beta.9",
   "module": "fesm2022/dsivd-prestations-ng.mjs",
   "typings": "types/dsivd-prestations-ng.d.ts",
   "exports": {

package/src/eslint/configs/__tests__/configs.test.mjs

@@ -1,3 +1,4 @@
+import vitest from '@vitest/eslint-plugin';
 import { builtinRules } from 'eslint/use-at-your-own-risk';
 import { describe, expect, it } from 'vitest';
 
@@ -6,6 +7,10 @@ import prestationsNg, { configs, plugin, rules } from '../../index.mjs';
 const PLUGIN_KEY = '@dsivd/prestations-ng';
 
 const configNames = Object.keys(configs);
+// The configs of this library's plugin (the preset of the Vitest specs only configures @vitest/eslint-plugin)
+const pluginConfigNames = configNames.filter(
+    (name) => name !== 'specTsRecommended',
+);
 
 // Configs that only register this library's rules, and the presets built on top of them.
 const RULE_LAYERS = ['tsRules', 'templateRules'];
@@ -52,6 +57,7 @@ describe('eslint configs', () => {
             'templateRecommended',
             'tsRules',
             'templateRules',
+            'specTsRecommended',
         ]);
     });
 
@@ -88,7 +94,7 @@ describe('eslint configs', () => {
 
     // Two entries declaring the same plugin key from different copies is a hard ESLint
     // failure, so the preset must register ours exactly once.
-    it.each(configNames)('%s should register the plugin once', (name) => {
+    it.each(pluginConfigNames)('%s should register the plugin once', (name) => {
         const declarations = configs[name]
             .map((entry) => entry.plugins?.[PLUGIN_KEY])
             .filter(Boolean);
@@ -101,7 +107,9 @@ describe('eslint configs', () => {
     });
 
     it('should enable every rule in at least one config', () => {
-        const enabled = new Set(configNames.flatMap((n) => ownIdsOf(configs[n])));
+        const enabled = new Set(
+            pluginConfigNames.flatMap((n) => ownIdsOf(configs[n])),
+        );
 
         for (const ruleName of Object.keys(rules)) {
             expect(enabled).toContain(`${PLUGIN_KEY}/${ruleName}`);
@@ -118,6 +126,42 @@ describe('eslint configs', () => {
     );
 });
 
+describe('specTsRecommended', () => {
+    const rulesOf = (config) =>
+        Object.assign({}, ...config.map((entry) => entry.rules ?? {}));
+
+    it('should build on the recommended config of @vitest/eslint-plugin', () => {
+        expect(configs.specTsRecommended[0]).toBe(vitest.configs.recommended);
+        expect(pluginsOf(configs.specTsRecommended)).toEqual({ vitest });
+    });
+
+    it('should count the assertions of the helpers and of the HttpTestingController', () => {
+        const [, options] = rulesOf(configs.specTsRecommended)[
+            'vitest/expect-expect'
+        ];
+
+        expect(options.assertFunctionNames).toEqual(
+            expect.arrayContaining([
+                'expect',
+                'expect*',
+                '*.expectOne',
+                '*.verify',
+            ]),
+        );
+    });
+
+    // An expect which may not run lets a test pass without asserting anything
+    it('should keep vitest/no-conditional-expect enabled', () => {
+        expect(
+            isOff(
+                rulesOf(configs.specTsRecommended)[
+                    'vitest/no-conditional-expect'
+                ],
+            ),
+        ).toBe(false);
+    });
+});
+
 describe('eslint plugin', () => {
     it('should be named after the npm package', () => {
         expect(plugin.meta.name).toBe(PLUGIN_KEY);

package/src/eslint/configs/spec-ts-recommended.mjs

@@ -0,0 +1,34 @@
+/**
+ * The house preset of the Vitest specs: the recommended rules of `@vitest/eslint-plugin`, with the
+ * assertions also made by the helpers of the specs and by the `HttpTestingController`.
+ *
+ * Meant for the `extends` of a `**\/*.spec.ts` block (the Cypress `*.spec.cy.ts` files are not
+ * Vitest specs).
+ *
+ * @param {import('@vitest/eslint-plugin').default} vitest the `@vitest/eslint-plugin` module
+ * @returns {import('typescript-eslint').ConfigArray}
+ */
+const specTsRecommended = (vitest) => [
+    vitest.configs.recommended,
+    {
+        name: 'prestations-ng/spec-ts-recommended',
+        rules: {
+            'vitest/expect-expect': [
+                'error',
+                {
+                    assertFunctionNames: [
+                        'expect',
+                        'expect*',
+                        'assert*',
+                        'test*',
+                        '*.expectOne',
+                        '*.expectNone',
+                        '*.verify',
+                    ],
+                },
+            ],
+        },
+    },
+];
+
+export default specTsRecommended;

package/src/eslint/index.mjs

@@ -1,9 +1,17 @@
+import specTsRecommended from './configs/spec-ts-recommended.mjs';
 import templateRecommended from './configs/template-recommended.mjs';
 import templateRules from './configs/template-rules.mjs';
 import tsRecommended from './configs/ts-recommended.mjs';
 import tsRules from './configs/ts-rules.mjs';
 import rules from './rules/index.mjs';
 
+// Only needed by the projects linting Vitest specs: the other configs can be used without it.
+const vitest = await import('@vitest/eslint-plugin').then(
+    (module) => module.default,
+    () => null,
+);
+const specTsRecommendedConfig = vitest ? specTsRecommended(vitest) : null;
+
 const plugin = {
     meta: { name: '@dsivd/prestations-ng' },
     rules,
@@ -16,6 +24,15 @@ const configs = {
     // Only this library's own rules, for a project that supplies its own style.
     tsRules: tsRules(plugin),
     templateRules: templateRules(plugin),
+    // The preset of the Vitest specs (needs @vitest/eslint-plugin)
+    get specTsRecommended() {
+        if (!specTsRecommendedConfig) {
+            throw new Error(
+                'prestationsNg.configs.specTsRecommended needs @vitest/eslint-plugin: npm install --save-dev @vitest/eslint-plugin@1',
+            );
+        }
+        return specTsRecommendedConfig;
+    },
 };
 
 export { configs, plugin, rules };

package/types/dsivd-prestations-ng.d.ts

@@ -1591,15 +1591,20 @@ declare class FoehnMultiselectAutocompleteComponent extends FoehnAutocompleteCom
     readonly defaultDeleteFocusArea: _angular_core.Signal<ElementRef<any> | undefined>;
     readonly defaultElementValuesComputed: _angular_core.Signal<unknown[]>;
     readonly autocompleteInputValue: _angular_core.WritableSignal<string | null>;
-    readonly showEmptyListMessage: _angular_core.WritableSignal<boolean>;
+    /**
+     * Every element is selected: a message replaces the autocomplete (not for an empty list of elements).
+     */
+    readonly showEmptyListMessage: _angular_core.Signal<boolean>;
     readonly srAnnouncements: _angular_core.WritableSignal<string>;
+    protected readonly suggestions: _angular_core.Signal<[]>;
     private readonly dictionaryService;
     private srAnnouncementClearTimer;
     private readonly SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS;
     private pendingRemovedIndexForFocus;
+    private readonly suggestionsEffect;
+    private readonly autocompleteInputVisibilityEffect;
     private readonly selectedElemRefEffect;
     ngOnInit(): void;
-    onModelChange(value: any): void;
     hasErrorsToDisplay(): boolean;
     getLabel(value: any): string | null | undefined;
     updateMultiselectAutocomplete(currentModel: unknown[]): void;
@@ -1608,18 +1613,16 @@ declare class FoehnMultiselectAutocompleteComponent extends FoehnAutocompleteCom
     removeItem(item: unknown, index: number): void;
     trackByFn(index: number): number;
     canBeDeleted(index: number): boolean;
-    onAutocompleteElementsLoaded(elements: []): void;
+    onAutocompleteElementsLoaded(): void;
     getDeleteButtonAriaLabel(element: unknown): string;
     hasDefaultDeleteFocusArea(): boolean;
     getBadgeLabel(element: any): string;
-    private manageListWhenElementsAreLoaded;
     private findElementByModelItem;
     private getValidValue;
     private focusNextAreaAfterDelete;
     private filterAutocompleteElements;
-    private manageSuggestionListAndFocusAfterAddingAnItem;
-    private manageSuggestionListAndFocusAfterRemovingAnItem;
-    private showAlertMessageAndHideAutocomplete;
+    private focusAfterAddingAnItem;
+    private applySuggestionsToAutocomplete;
     private manageScreenReaderAnnouncement;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FoehnMultiselectAutocompleteComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FoehnMultiselectAutocompleteComponent, "foehn-multiselect-autocomplete", never, { "elementBadgeLabel": { "alias": "elementBadgeLabel"; "required": false; "isSignal": true; }; "selectedItemsListLegend": { "alias": "selectedItemsListLegend"; "required": false; "isSignal": true; }; "noElementsSelectedLabel": { "alias": "noElementsSelectedLabel"; "required": false; "isSignal": true; }; "excludeFromErrorSummary": { "alias": "excludeFromErrorSummary"; "required": false; "isSignal": true; }; "defaultElementValues": { "alias": "defaultElementValues"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
@@ -2476,13 +2479,18 @@ declare class UploaderHelper {
     get accept(): string;
     set accept(value: string);
     getMaxFileSizeInBytesForFormKey(formKey: string): number | undefined | null;
-    isFileTooBig(formKey: string, fileSizeInBytes: number): boolean;
+    /**
+     * The maximum size of a file: the one of its form key (application info) and `maxFileSizeInMo` (a limit of the
+     * component), the smallest of both.
+     */
+    getMaxFileSizeInBytes(formKey: string, maxFileSizeInMo?: number): number | null;
+    isFileTooBig(formKey: string, fileSizeInBytes: number, maxFileSizeInMo?: number): boolean;
     isFileTooSmall(fileSizeInBytes: number): boolean;
     isFileNameLengthValid(filename: string, overrideMaxFileNameLength?: number): boolean;
     isFileNameNameValid(filename: string, overrideIllegalCharacters?: string): boolean;
     getFileExtension(filename: string): string;
     isFileExtensionValid(fileExtension: string, overrideAcceptedExtensions?: string): boolean;
-    getUniqueErrorByCode(name: string, errorCode: string, fileName: string, customErrors: Record<string, string>, overrideAcceptedExtensions?: string, overrideMaxFileNameLength?: number, overrideIllegalCharacters?: string): FormError;
+    getUniqueErrorByCode(name: string, errorCode: string, fileName: string, customErrors: Record<string, string>, overrideAcceptedExtensions?: string, overrideMaxFileNameLength?: number, overrideIllegalCharacters?: string, maxFileSizeInMo?: number): FormError;
     addCustomErrorOrDefault(name: string, destinationErrors: FormError[], errorCode: string, fileName: string, customErrors: Record<string, string>, overrideAcceptedExtensions?: string, overrideMaxFileNameLength?: number, overrideIllegalCharacters?: string): void;
     /**
      * The default messages of the upload errors, in the current language.
@@ -2496,7 +2504,7 @@ declare class UploaderHelper {
      * @deprecated Overwrites the given custom errors with the default messages: use `mergeCustomErrors()`.
      */
     createDefaultCustomErrors(customErrors: Record<string, string>): void;
-    getLocalErrors(name: string, files: File[], customErrors: Record<string, string>, overrideAcceptedExtensions?: string, overrideMaxFileNameLength?: number, overrideIllegalCharacters?: string): FormError[];
+    getLocalErrors(name: string, files: File[], customErrors: Record<string, string>, overrideAcceptedExtensions?: string, overrideMaxFileNameLength?: number, overrideIllegalCharacters?: string, maxFileSizeInMo?: number): FormError[];
     hasLiveUploadErrors(errors: FormError[]): boolean;
     preventAndStop(event: any): void;
     getAllFilesCount(data: any): string | null;
@@ -2572,6 +2580,10 @@ declare abstract class AbstractFoehnUploaderComponent<T> extends FoehnInputCompo
     toMegaOctets(size: number): number;
     hasLiveUploadErrors(): boolean;
     protected removeFileOnConfirmation(document: DocumentReference | File): void;
+    /**
+     * A maximum size of each file, in addition to the one of its form key in the application info.
+     */
+    protected getMaxFileSizeInMo(): number | undefined;
     protected displayLocalErrors(files: File[]): FormError[];
     protected isMaxSelectionReached(files: File[]): boolean;
     protected isMaxFilesCountReached(files: File[]): boolean;
@@ -2755,9 +2767,9 @@ declare class FoehnBoMultiUploadComponent extends AbstractFoehnUploaderComponent
     canAddMoreFiles(): boolean;
     onFileChange(event: Event): void;
     onDrop(event: any): void;
+    protected getMaxFileSizeInMo(): number | undefined;
     protected removeFileOnConfirmation(document: DocumentReference | File): void;
     private populateFileItemList;
-    private tooBigErrors;
     private addFilesLocally;
     private toPendingDocument;
     private removeDocumentLocally;