@acorex/core 21.0.2-next.4 → 21.0.2-next.40

package/fesm2022/acorex-core-file.mjs

@@ -1,5 +1,7 @@
 import * as i0 from '@angular/core';
-import { Injectable, NgModule, inject, DOCUMENT, PLATFORM_ID } from '@angular/core';
+import { Injectable, InjectionToken, inject, NgModule, DOCUMENT, isDevMode } from '@angular/core';
+import * as i2 from '@acorex/core/validation';
+import { AXValidationService, AXValidationRegistryService, AXValidationModule } from '@acorex/core/validation';
 import * as i1 from '@acorex/core/format';
 import { AXFormatModule } from '@acorex/core/format';
 
@@ -29,24 +31,585 @@ class AXFileSizeFormatter {
         const i = Math.floor(Math.log(size) / Math.log(k));
         return parseFloat((size / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileSizeFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileSizeFormatter }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileSizeFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileSizeFormatter }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileSizeFormatter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileSizeFormatter, decorators: [{
             type: Injectable
         }] });
 
+/** Human-readable file size (binary units, e.g. `41.5 MB`). */
+function formatFileSizeBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0) {
+        return '0 B';
+    }
+    if (bytes === 0) {
+        return '0 B';
+    }
+    const k = 1024;
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), units.length - 1);
+    const value = bytes / Math.pow(k, i);
+    if (i === 0) {
+        return `${bytes} B`;
+    }
+    const digits = value >= 100 ? 0 : value >= 10 ? 1 : 2;
+    return `${value.toFixed(digits)} ${units[i]}`;
+}
+
+/** Resolves clipboard/plain text from a copy result. */
+function resolveFileCopyText(result) {
+    if (result == null) {
+        return null;
+    }
+    if (typeof result === 'string') {
+        const trimmed = result.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    const trimmed = result.text?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+
+/** Contributes {@link AXFileType} entries (multi provider). */
+class AXFileTypeInfoProvider {
+}
+const AX_FILE_TYPE_INFO_PROVIDER = new InjectionToken('AX_FILE_TYPE_INFO_PROVIDER');
+function provideFileTypeInfoProvider(provider) {
+    return {
+        provide: AX_FILE_TYPE_INFO_PROVIDER,
+        useClass: provider,
+        multi: true,
+    };
+}
+
+/** Merges type-level validations with extension overrides (extension wins per field). */
+function mergeFileValidations(base, override) {
+    if (!override) {
+        return { ...base };
+    }
+    return {
+        mimeTypes: override.mimeTypes ?? base.mimeTypes,
+        minSize: override.minSize ?? base.minSize,
+        maxSize: override.maxSize ?? base.maxSize,
+        rules: override.rules ?? base.rules,
+    };
+}
+/** Resolved validations for a type + optional extension. */
+function resolveFileValidations(type, extension) {
+    return mergeFileValidations(type.validations ?? {}, extension?.validations);
+}
+/** True when no mime/size/rules are defined on the type. */
+function isEmptyFileValidations(validations) {
+    if (!validations) {
+        return true;
+    }
+    return ((validations.mimeTypes?.length ?? 0) === 0 &&
+        validations.minSize == null &&
+        validations.maxSize == null &&
+        (validations.rules?.length ?? 0) === 0);
+}
+/**
+ * Extension-only mode: empty type `validations` and a non-empty `extensions` list.
+ * Files must match a listed extension; rules come from that extension entry.
+ */
+function isExtensionsOnlyType(type) {
+    return isEmptyFileValidations(type.validations) && (type.extensions?.length ?? 0) > 0;
+}
+/** File extension from name (lowercase, no dot). */
+function getFileExtension(fileName) {
+    const parts = fileName.trim().split('.');
+    return parts.length > 1 ? (parts.pop()?.toLowerCase() ?? '') : '';
+}
+/** Matching extension entry for a file within a type, if any. */
+function findFileTypeExtension(file, type) {
+    const ext = getFileExtension(file.name);
+    if (!ext || !type.extensions?.length) {
+        return undefined;
+    }
+    return type.extensions.find((e) => e.name.toLowerCase() === ext);
+}
+
+/** Maps {@link AXFileValidations} to executable validation entries. */
+function fileValidationsToRules(validations) {
+    const rules = [];
+    if (validations.mimeTypes?.length) {
+        rules.push({
+            rule: 'fileMimeType',
+            options: { allowed: validations.mimeTypes },
+        });
+    }
+    if (validations.minSize != null) {
+        rules.push({
+            rule: 'fileMinSize',
+            options: { minSize: validations.minSize },
+        });
+    }
+    if (validations.maxSize != null) {
+        rules.push({
+            rule: 'fileMaxSize',
+            options: { maxSize: validations.maxSize },
+        });
+    }
+    if (validations.rules?.length) {
+        rules.push(...validations.rules);
+    }
+    return rules;
+}
+/** Failed validation results; empty array means the file is valid. */
+async function validateFileWithValidations(validation, file, validations) {
+    const entries = fileValidationsToRules(validations);
+    const errors = [];
+    for (const { rule, options } of entries) {
+        const result = await validation.validate(rule, file, options);
+        if (!result.result) {
+            errors.push(result);
+        }
+    }
+    return errors;
+}
+/** Validates a file against a type; extension rules override when the file name matches. */
+async function validateFileAgainstType(validation, file, type, extension) {
+    const matchedExtension = extension ?? findFileTypeExtension(file, type);
+    if (isExtensionsOnlyType(type) && !matchedExtension) {
+        const ext = getFileExtension(file.name);
+        return [
+            {
+                rule: 'fileExtension',
+                result: false,
+                message: ext ? `Extension ".${ext}" is not allowed.` : 'File must have an allowed extension.',
+                value: ext,
+            },
+        ];
+    }
+    const resolved = resolveFileValidations(type, matchedExtension);
+    return validateFileWithValidations(validation, file, resolved);
+}
+
+class AXFileTypeRegistryService {
+    constructor() {
+        this.validation = inject(AXValidationService);
+        this.providers = inject(AX_FILE_TYPE_INFO_PROVIDER, { optional: true }) ?? [];
+        this.registeredTypes = [];
+        this.cache = null;
+    }
+    /** Registers or replaces catalog entries (e.g. from feature bootstrap). */
+    registerTypes(types) {
+        for (const type of types) {
+            const index = this.registeredTypes.findIndex((t) => t.name === type.name);
+            if (index >= 0) {
+                this.registeredTypes[index] = type;
+            }
+            else {
+                this.registeredTypes.push(type);
+            }
+        }
+        this.invalidateCache();
+    }
+    invalidateCache() {
+        this.cache = null;
+    }
+    async resolveTypes() {
+        if (this.cache) {
+            return this.cache;
+        }
+        const byName = new Map();
+        if (this.providers.length) {
+            const batches = await Promise.all(this.providers.map((p) => p.items()));
+            for (const batch of batches) {
+                for (const type of batch) {
+                    if (!byName.has(type.name)) {
+                        byName.set(type.name, type);
+                    }
+                }
+            }
+        }
+        for (const type of this.registeredTypes) {
+            byName.set(type.name, type);
+        }
+        this.cache = [...byName.values()];
+        return this.cache;
+    }
+    async getTypes() {
+        return this.resolveTypes();
+    }
+    async get(name) {
+        const types = await this.resolveTypes();
+        return types.find((t) => t.name === name);
+    }
+    async accept(typeNames) {
+        const names = typeNames ? (Array.isArray(typeNames) ? typeNames : [typeNames]) : undefined;
+        const types = await this.resolveTypes();
+        const selected = names?.length ? types.filter((t) => names.includes(t.name)) : types;
+        if (names?.length && selected.length === 0) {
+            return '';
+        }
+        const parts = new Set();
+        for (const type of selected) {
+            type.validations?.mimeTypes?.forEach((m) => parts.add(m));
+            type.extensions?.forEach((ext) => {
+                ext.validations?.mimeTypes?.forEach((m) => parts.add(m));
+                parts.add(`.${ext.name.replace(/^\./, '')}`);
+            });
+        }
+        return [...parts].join(',');
+    }
+    async matchType(file) {
+        const types = await this.resolveTypes();
+        const mime = file.type.trim().toLowerCase();
+        return types.find((type) => {
+            const patterns = [
+                ...(type.validations?.mimeTypes ?? []),
+                ...(type.extensions?.flatMap((e) => e.validations?.mimeTypes ?? []) ?? []),
+            ];
+            if (!patterns.length) {
+                return false;
+            }
+            return patterns.some((pattern) => this.matchesMime(mime, pattern.trim().toLowerCase()));
+        });
+    }
+    async validate(file, typeName) {
+        const type = await this.get(typeName);
+        if (!type) {
+            return [
+                {
+                    rule: 'fileType',
+                    result: false,
+                    message: `Unknown file type: ${typeName}`,
+                    value: typeName,
+                },
+            ];
+        }
+        const extension = findFileTypeExtension(file, type);
+        return validateFileAgainstType(this.validation, file, type, extension);
+    }
+    async validateAgainstTypes(file, typeNames) {
+        const names = Array.isArray(typeNames) ? typeNames : [typeNames];
+        let lastErrors = [];
+        for (const name of names) {
+            const errors = await this.validate(file, name);
+            if (errors.length === 0) {
+                return [];
+            }
+            lastErrors = errors;
+        }
+        return lastErrors;
+    }
+    async validateMany(files, typeNames) {
+        const accepted = [];
+        const rejected = [];
+        for (const file of files) {
+            const errors = await this.validateAgainstTypes(file, typeNames);
+            if (errors.length === 0) {
+                accepted.push(file);
+            }
+            else {
+                rejected.push({ file, errors });
+            }
+        }
+        return { accepted, rejected };
+    }
+    matchesMime(mime, pattern) {
+        if (!pattern || pattern === '*/*' || pattern === '*') {
+            return true;
+        }
+        if (pattern.endsWith('/*')) {
+            const category = pattern.slice(0, -2);
+            return mime.startsWith(`${category}/`) || (mime === '' && category === 'application');
+        }
+        return mime === pattern;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileTypeRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileTypeRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileTypeRegistryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const MB$4 = 1024 * 1024;
+const AX_AUDIO_FILE_TYPE = {
+    name: 'audio',
+    title: 'Audio',
+    icon: 'fa-light fa-music ax-text-amber-500',
+    validations: {
+        mimeTypes: ['audio/*'],
+        minSize: 1,
+        maxSize: 50 * MB$4,
+    },
+    extensions: [
+        { name: 'mp3', title: 'MP3' },
+        { name: 'wav', title: 'WAV', validations: { maxSize: 30 * MB$4 } },
+        { name: 'ogg', title: 'OGG' },
+        { name: 'm4a', title: 'M4A' },
+    ],
+};
+class AXAudioFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([AX_AUDIO_FILE_TYPE]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXAudioFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXAudioFileTypeProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXAudioFileTypeProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const MB$3 = 1024 * 1024;
+/** Extension-only: no type `validations` — only listed extensions are allowed. */
+const AX_DOCUMENT_FILE_TYPE = {
+    name: 'document',
+    title: 'Document',
+    icon: 'fa-light fa-file-lines ax-text-red-500',
+    extensions: [{ name: 'pdf', title: 'PDF', validations: { mimeTypes: ['application/pdf'], maxSize: 5 * MB$3 } }],
+};
+class AXDocumentFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([AX_DOCUMENT_FILE_TYPE]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXDocumentFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXDocumentFileTypeProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXDocumentFileTypeProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const MB$2 = 1024 * 1024;
+const AX_FILE_FILE_TYPE = {
+    name: 'file',
+    title: 'File',
+    icon: 'fa-light fa-file ax-text-neutral-500',
+    validations: {
+        mimeTypes: ['application/*', 'text/*'],
+        minSize: 1,
+        maxSize: 100 * MB$2,
+    },
+    extensions: [
+        { name: 'pdf', title: 'PDF', validations: { mimeTypes: ['application/pdf'], maxSize: 25 * MB$2 } },
+        { name: 'doc', title: 'Word' },
+        { name: 'docx', title: 'Word' },
+        { name: 'txt', title: 'Text', validations: { mimeTypes: ['text/plain'], maxSize: 5 * MB$2 } },
+        { name: 'zip', title: 'ZIP', validations: { maxSize: 50 * MB$2 } },
+    ],
+};
+class AXFileFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([AX_FILE_FILE_TYPE]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileFileTypeProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileFileTypeProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const MB$1 = 1024 * 1024;
+const AX_IMAGE_FILE_TYPE = {
+    name: 'image',
+    title: 'Image',
+    icon: 'fa-light fa-image ax-text-purple-500',
+    validations: {
+        mimeTypes: ['image/*'],
+        minSize: 1,
+        maxSize: 100 * MB$1,
+    },
+    extensions: [
+        { name: 'jpg', title: 'JPEG' },
+        { name: 'jpeg', title: 'JPEG', validations: { maxSize: 5 * MB$1 } },
+        { name: 'png', title: 'PNG' },
+        { name: 'gif', title: 'GIF' },
+        { name: 'webp', title: 'WebP' },
+        { name: 'svg', title: 'SVG', validations: { maxSize: 2 * MB$1 } },
+    ],
+};
+class AXImageFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([AX_IMAGE_FILE_TYPE]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXImageFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXImageFileTypeProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXImageFileTypeProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const MB = 1024 * 1024;
+const AX_VIDEO_FILE_TYPE = {
+    name: 'video',
+    title: 'Video',
+    icon: 'fa-light fa-video ax-text-blue-500',
+    validations: {
+        mimeTypes: ['video/*'],
+        minSize: 1,
+        maxSize: 500 * MB,
+    },
+    extensions: [
+        { name: 'mp4', title: 'MP4' },
+        { name: 'webm', title: 'WebM', validations: { maxSize: 200 * MB } },
+        { name: 'ogg', title: 'OGG' },
+    ],
+};
+class AXVideoFileTypeProvider extends AXFileTypeInfoProvider {
+    items() {
+        return Promise.resolve([AX_VIDEO_FILE_TYPE]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXVideoFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXVideoFileTypeProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXVideoFileTypeProvider, decorators: [{
+            type: Injectable
+        }] });
+
+/** Built-in file type provider classes (one logical type per provider). */
+const AX_BUILTIN_FILE_TYPE_PROVIDERS = [
+    AXImageFileTypeProvider,
+    AXVideoFileTypeProvider,
+    AXAudioFileTypeProvider,
+    AXFileFileTypeProvider,
+    AXDocumentFileTypeProvider,
+];
+/** Registers all built-in file type providers (image, video, audio, file, document). */
+function provideBuiltinFileTypeProviders() {
+    return AX_BUILTIN_FILE_TYPE_PROVIDERS.map((provider) => provideFileTypeInfoProvider(provider));
+}
+/** @deprecated Use {@link provideBuiltinFileTypeProviders}. */
+const provideDefaultFileTypeProviders = provideBuiltinFileTypeProviders;
+
+class AXFileMimeTypeValidationRule {
+    get name() {
+        return 'fileMimeType';
+    }
+    async validate(value, options) {
+        const mime = (value instanceof File || value instanceof Blob ? value.type : '').trim().toLowerCase();
+        const allowed = options.allowed ?? [];
+        const valid = allowed.length === 0 ||
+            allowed.some((pattern) => this.matchesMime(mime, pattern.trim().toLowerCase()));
+        return {
+            rule: this.name,
+            result: valid,
+            message: valid ? '' : (options.message ?? 'File type is not allowed.'),
+            value: mime,
+        };
+    }
+    matchesMime(mime, pattern) {
+        if (!pattern || pattern === '*/*' || pattern === '*') {
+            return true;
+        }
+        if (pattern.endsWith('/*')) {
+            const category = pattern.slice(0, -2);
+            return mime.startsWith(`${category}/`) || (mime === '' && category === 'application');
+        }
+        return mime === pattern;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMimeTypeValidationRule, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMimeTypeValidationRule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMimeTypeValidationRule, decorators: [{
+            type: Injectable
+        }] });
+
+class AXFileMinSizeValidationRule {
+    get name() {
+        return 'fileMinSize';
+    }
+    async validate(value, options) {
+        const size = value instanceof File || value instanceof Blob ? value.size : 0;
+        const valid = size >= options.minSize;
+        const limitLabel = formatFileSizeBytes(options.minSize);
+        return {
+            rule: this.name,
+            result: valid,
+            message: valid
+                ? ''
+                : (options.message ?? `File is too small. Minimum size is ${limitLabel}.`),
+            value: size,
+            minSize: options.minSize,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMinSizeValidationRule, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMinSizeValidationRule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMinSizeValidationRule, decorators: [{
+            type: Injectable
+        }] });
+
+class AXFileMaxSizeValidationRule {
+    get name() {
+        return 'fileMaxSize';
+    }
+    async validate(value, options) {
+        const size = value instanceof File || value instanceof Blob ? value.size : 0;
+        const valid = size <= options.maxSize;
+        const limitLabel = formatFileSizeBytes(options.maxSize);
+        return {
+            rule: this.name,
+            result: valid,
+            message: valid
+                ? ''
+                : (options.message ??
+                    `File is too large. Maximum size is ${limitLabel}.`),
+            value: size,
+            maxSize: options.maxSize,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMaxSizeValidationRule, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMaxSizeValidationRule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileMaxSizeValidationRule, decorators: [{
+            type: Injectable
+        }] });
+
+/** Validation rule classes to register with {@link AXValidationModule}. */
+const AX_FILE_VALIDATION_RULES = [
+    AXFileMimeTypeValidationRule,
+    AXFileMinSizeValidationRule,
+    AXFileMaxSizeValidationRule,
+];
+/** Registers file validation rules with {@link AXValidationRegistryService}. */
+function provideFileValidationRules() {
+    return {
+        provide: 'AXValidationModuleFactory',
+        useFactory: (registry) => () => {
+            registry.register(...AX_FILE_VALIDATION_RULES);
+        },
+        deps: [AXValidationRegistryService],
+        multi: true,
+    };
+}
+/**
+ * Registers validation rules and optional built-in file type providers.
+ * {@link AXFileTypeRegistryService} and {@link AXFileService} are `providedIn: 'root'`.
+ */
+function provideFileTypeSystem() {
+    return [provideFileValidationRules(), ...provideBuiltinFileTypeProviders()];
+}
+
 class AXFileModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: AXFileModule, imports: [i1.AXFormatModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileModule, providers: [AXFileSizeFormatter], imports: [AXFormatModule.forChild({ formatters: [AXFileSizeFormatter] })] }); }
+    static forRoot(config) {
+        const includeDefaults = config?.includeDefaultFileTypes !== false;
+        return {
+            ngModule: AXFileModule,
+            providers: [
+                provideFileValidationRules(),
+                ...(includeDefaults ? provideDefaultFileTypeProviders() : []),
+                ...(config?.fileTypeProviders ?? []),
+            ],
+        };
+    }
+    static forChild(config) {
+        return AXFileModule.forRoot(config);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXFileModule, imports: [i1.AXFormatModule, i2.AXValidationModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileModule, providers: [AXFileSizeFormatter], imports: [AXFormatModule.forChild({ formatters: [AXFileSizeFormatter] }),
+            AXValidationModule.forChild({ rules: [...AX_FILE_VALIDATION_RULES] })] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [AXFormatModule.forChild({ formatters: [AXFileSizeFormatter] })],
-                    exports: [],
-                    declarations: [],
+                    imports: [
+                        AXFormatModule.forChild({ formatters: [AXFileSizeFormatter] }),
+                        AXValidationModule.forChild({ rules: [...AX_FILE_VALIDATION_RULES] }),
+                    ],
                     providers: [AXFileSizeFormatter],
                 }]
         }] });
@@ -54,112 +617,124 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
 class AXFileService {
     constructor() {
         this.document = inject(DOCUMENT);
-        this.platformID = inject(PLATFORM_ID);
-        /**
-         * Gets the size of a file, blob, or base64 string.
-         *
-         * @param file - The file, blob, or base64 string to get size for
-         * @returns number | false - The size in bytes or false if not a base64 string
-         */
-        this.blobToBase64 = (blob) => {
-            if (blob instanceof Blob) {
-                return new Promise((resolve, reject) => {
-                    const reader = new FileReader();
-                    reader.onerror = reject;
-                    reader.onload = () => {
-                        resolve(reader.result);
-                    };
-                    reader.readAsDataURL(blob);
-                });
-            }
-            else {
-                return Promise.reject('input is not blob');
-            }
-        };
+        this.fileTypes = inject(AXFileTypeRegistryService);
+    }
+    async getFileTypes() {
+        return this.fileTypes.getTypes();
+    }
+    async getFileType(name) {
+        return this.fileTypes.get(name);
+    }
+    async getAcceptAttribute(fileType) {
+        return this.fileTypes.accept(fileType);
+    }
+    async matchFileType(file) {
+        return this.fileTypes.matchType(file);
+    }
+    validate(file, fileType) {
+        return this.fileTypes.validateAgainstTypes(file, fileType);
+    }
+    validateMany(files, fileType) {
+        return this.fileTypes.validateMany(files, fileType);
     }
     /**
-     * Opens a file selection dialog and returns the selected files.
-     *
-     * @param options - Optional configuration for file selection
-     * @param options.accept - File types to accept (e.g., 'image/*', '.pdf')
-     * @param options.multiple - Whether to allow multiple file selection
-     * @returns Promise<File[]> - Promise that resolves with the selected files
+     * Opens a file selection dialog.
+     * With `fileType`, returns files that pass catalog validation (`accept` defaults from the catalog).
+     * Without `fileType`, returns all selected files (legacy `accept` / `multiple` only).
      */
-    choose(options) {
+    async chooseValidated(options) {
+        const resolved = await this.resolveChooseOptions(options);
+        const files = await this.openFileDialog(resolved);
+        if (files.length === 0) {
+            return { accepted: [], rejected: [] };
+        }
+        if (options.fileType) {
+            return this.validateMany(files, options.fileType);
+        }
+        return { accepted: files, rejected: [] };
+    }
+    async choose(options) {
+        const { accepted } = await this.chooseValidated(options);
+        return accepted;
+    }
+    blobToBase64(blob) {
+        if (!(blob instanceof Blob)) {
+            return Promise.reject(new Error('input is not blob'));
+        }
         return new Promise((resolve, reject) => {
-            options = Object.assign({ multiple: false }, options);
-            const input = this.document.createElement('input');
-            input.style.display = 'none';
-            this.document.body.appendChild(input);
-            input.type = 'file';
-            input.accept = options.accept || '';
-            input.multiple = options.multiple || false;
-            //
-            const onError = (e) => {
-                reject(e);
-                this.document.body.removeChild(input);
-                input.remove();
-                input.removeEventListener('change', onChange);
-                input.removeEventListener('error', onError);
-            };
-            //
-            const onChange = () => {
-                resolve(Array.from(input.files || []));
-                this.document.body.removeChild(input);
-                input.remove();
-                input.removeEventListener('change', onChange);
-                input.removeEventListener('error', onError);
-            };
-            //
-            input.addEventListener('change', onChange);
-            input.addEventListener('error', onError);
-            input.click();
+            const reader = new FileReader();
+            reader.onerror = () => reject(reader.error);
+            reader.onload = () => resolve(reader.result);
+            reader.readAsDataURL(blob);
         });
     }
-    /**
-     * Gets the size of a file, blob, or base64 string.
-     *
-     * @param file - The file, blob, or base64 string to get size for
-     * @returns number | false - The size in bytes or false if not a base64 string
-     */
     getSize(file) {
         if (this.isBase64(file)) {
             return this.getBase64Size(file);
         }
         return false;
     }
-    /**
-     * Checks if a string is a valid base64 string.
-     *
-     * @param base64 - The string to check
-     * @returns boolean - True if the string is a valid base64 string
-     */
     isBase64(base64) {
         const regx = /[^:]\w+\/[\w-+\d.]+(?=;|,)/;
         return regx.test(base64);
     }
-    /**
-     * Gets the size of a base64 string in bytes.
-     *
-     * @param base64 - The base64 string to get size for
-     * @returns number - The size in bytes
-     */
     getBase64Size(base64) {
         return atob(base64.substring(base64.indexOf(',') + 1)).length;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileService, providedIn: 'root' }); }
+    async resolveChooseOptions(options) {
+        const multiple = options.multiple ?? false;
+        if (options.fileType) {
+            const accept = options.accept ?? (await this.getAcceptAttribute(options.fileType));
+            if (isDevMode() && !accept) {
+                const name = Array.isArray(options.fileType) ? options.fileType.join(', ') : options.fileType;
+                console.warn(`[AXFileService] No accept filter for file type "${name}". ` +
+                    'Register a file type provider (e.g. provideConversationFileCatalog).');
+            }
+            return { accept, multiple };
+        }
+        return { accept: options.accept ?? '', multiple };
+    }
+    openFileDialog(options) {
+        return new Promise((resolve, reject) => {
+            const input = this.document.createElement('input');
+            input.style.display = 'none';
+            this.document.body.appendChild(input);
+            input.type = 'file';
+            input.accept = options.accept;
+            input.multiple = options.multiple;
+            const cleanup = () => {
+                input.removeEventListener('change', onChange);
+                input.removeEventListener('error', onError);
+                if (input.parentNode) {
+                    this.document.body.removeChild(input);
+                }
+                input.remove();
+            };
+            const onError = (e) => {
+                cleanup();
+                reject(e);
+            };
+            const onChange = () => {
+                const files = Array.from(input.files ?? []);
+                cleanup();
+                resolve(files);
+            };
+            input.addEventListener('change', onChange);
+            input.addEventListener('error', onError);
+            input.click();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileService, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+            args: [{ providedIn: 'root' }]
         }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXFileModule, AXFileService, AXFileSizeFormatter };
+export { AXAudioFileTypeProvider, AXDocumentFileTypeProvider, AXFileFileTypeProvider, AXFileMaxSizeValidationRule, AXFileMimeTypeValidationRule, AXFileMinSizeValidationRule, AXFileModule, AXFileService, AXFileSizeFormatter, AXFileTypeInfoProvider, AXFileTypeRegistryService, AXImageFileTypeProvider, AXVideoFileTypeProvider, AX_AUDIO_FILE_TYPE, AX_BUILTIN_FILE_TYPE_PROVIDERS, AX_DOCUMENT_FILE_TYPE, AX_FILE_FILE_TYPE, AX_FILE_TYPE_INFO_PROVIDER, AX_FILE_VALIDATION_RULES, AX_IMAGE_FILE_TYPE, AX_VIDEO_FILE_TYPE, fileValidationsToRules, findFileTypeExtension, formatFileSizeBytes, getFileExtension, isEmptyFileValidations, isExtensionsOnlyType, mergeFileValidations, provideBuiltinFileTypeProviders, provideDefaultFileTypeProviders, provideFileTypeInfoProvider, provideFileTypeSystem, provideFileValidationRules, resolveFileCopyText, resolveFileValidations, validateFileAgainstType, validateFileWithValidations };
 //# sourceMappingURL=acorex-core-file.mjs.map