@acorex/core 21.0.2-next.24 → 21.0.2-next.26

package/fesm2022/acorex-core-file.mjs

@@ -1,7 +1,5 @@
 import * as i0 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 { Injectable, NgModule, inject, DOCUMENT, PLATFORM_ID } from '@angular/core';
 import * as i1 from '@acorex/core/format';
 import { AXFormatModule } from '@acorex/core/format';
 
@@ -31,603 +29,24 @@ 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: "20.3.3", ngImport: i0, type: AXFileSizeFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileSizeFormatter }); }
+    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 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileSizeFormatter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", 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]}`;
-}
-
-/** Well-known utility keys (optional per {@link AXFileType}). */
-const AX_FILE_TYPE_UTILITY = {
-    preview: 'preview',
-    duration: 'duration',
-    formatSize: 'formatSize',
-    formatDuration: 'formatDuration',
-    createLocalPreviewUrl: 'createLocalPreviewUrl',
-    /** Resolves catalog name for mixed file-picker rows. */
-    pickerCatalog: 'pickerCatalog',
-};
-function createFileTypeUtilitiesContext(readAsDataUrl, platformId) {
-    return { readAsDataUrl, platformId };
-}
-function hasFileTypeUtility(fileType, name) {
-    return typeof fileType?.utilities?.[name] === 'function';
-}
-async function runFileTypeUtility(fileType, name, ctx, ...args) {
-    const fn = fileType?.utilities?.[name];
-    if (!fn) {
-        return undefined;
-    }
-    return (await fn(ctx, ...args));
-}
-function runFileTypeUtilitySync(fileType, name, ctx, ...args) {
-    const fn = fileType?.utilities?.[name];
-    if (!fn) {
-        return undefined;
-    }
-    return fn(ctx, ...args);
-}
-
-/** 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: "20.3.3", ngImport: i0, type: AXFileTypeRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileTypeRegistryService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXAudioFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXAudioFileTypeProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXDocumentFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXDocumentFileTypeProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXFileFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileFileTypeProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXImageFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXImageFileTypeProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXVideoFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXVideoFileTypeProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXFileMimeTypeValidationRule, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileMimeTypeValidationRule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXFileMinSizeValidationRule, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileMinSizeValidationRule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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: "20.3.3", ngImport: i0, type: AXFileMaxSizeValidationRule, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileMaxSizeValidationRule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", 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 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: "20.3.3", ngImport: i0, type: AXFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.3", ngImport: i0, type: AXFileModule, imports: [i1.AXFormatModule, i2.AXValidationModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileModule, providers: [AXFileSizeFormatter], imports: [AXFormatModule.forChild({ formatters: [AXFileSizeFormatter] }),
-            AXValidationModule.forChild({ rules: [...AX_FILE_VALIDATION_RULES] })] }); }
+    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] })] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [
-                        AXFormatModule.forChild({ formatters: [AXFileSizeFormatter] }),
-                        AXValidationModule.forChild({ rules: [...AX_FILE_VALIDATION_RULES] }),
-                    ],
+                    imports: [AXFormatModule.forChild({ formatters: [AXFileSizeFormatter] })],
+                    exports: [],
+                    declarations: [],
                     providers: [AXFileSizeFormatter],
                 }]
         }] });
@@ -635,124 +54,112 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImpor
 class AXFileService {
     constructor() {
         this.document = inject(DOCUMENT);
-        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);
+        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');
+            }
+        };
     }
     /**
-     * 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).
+     * 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
      */
-    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'));
-        }
+    choose(options) {
         return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onerror = () => reject(reader.error);
-            reader.onload = () => resolve(reader.result);
-            reader.readAsDataURL(blob);
+            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();
         });
     }
+    /**
+     * 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;
     }
-    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: "20.3.3", ngImport: i0, type: AXFileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileService, providedIn: 'root' }); }
+    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' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXFileService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AXFileService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
+            args: [{
+                    providedIn: 'root',
+                }]
         }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-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_TYPE_UTILITY, AX_FILE_VALIDATION_RULES, AX_IMAGE_FILE_TYPE, AX_VIDEO_FILE_TYPE, createFileTypeUtilitiesContext, fileValidationsToRules, findFileTypeExtension, formatFileSizeBytes, getFileExtension, hasFileTypeUtility, isEmptyFileValidations, isExtensionsOnlyType, mergeFileValidations, provideBuiltinFileTypeProviders, provideDefaultFileTypeProviders, provideFileTypeInfoProvider, provideFileTypeSystem, provideFileValidationRules, resolveFileValidations, runFileTypeUtility, runFileTypeUtilitySync, validateFileAgainstType, validateFileWithValidations };
+export { AXFileModule, AXFileService, AXFileSizeFormatter };
 //# sourceMappingURL=acorex-core-file.mjs.map