@acorex/core 21.0.3-next.9 → 21.1.0-next.1

package/fesm2022/acorex-core-file.mjs

@@ -1,5 +1,6 @@
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, inject, NgModule, DOCUMENT, isDevMode } from '@angular/core';
+import { Injectable, runInInjectionContext, InjectionToken, inject, input, signal, effect, ChangeDetectionStrategy, Component, NgModule, DOCUMENT, isDevMode } from '@angular/core';
+import { NgComponentOutlet } from '@angular/common';
 import * as i2 from '@acorex/core/validation';
 import { AXValidationService, AXValidationRegistryService, AXValidationModule } from '@acorex/core/validation';
 import * as i1 from '@acorex/core/format';
@@ -57,6 +58,38 @@ function formatFileSizeBytes(bytes) {
     return `${value.toFixed(digits)} ${units[i]}`;
 }
 
+/** Metadata key for catalog usage context. */
+const AX_FILE_TYPE_METADATA_PURPOSE = 'purpose';
+
+const CONVERSATION_NAME_PREFIX = 'conversation-';
+function getFileTypePurposes(type) {
+    const raw = type.metadata?.[AX_FILE_TYPE_METADATA_PURPOSE];
+    if (Array.isArray(raw)) {
+        const values = raw.filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+        if (values.length) {
+            return values;
+        }
+    }
+    if (type.name.startsWith(CONVERSATION_NAME_PREFIX)) {
+        return ['conversation'];
+    }
+    return ['system'];
+}
+function fileTypeMatchesPurpose(type, purpose) {
+    const allowed = Array.isArray(purpose) ? purpose : [purpose];
+    return getFileTypePurposes(type).some((entry) => allowed.includes(entry));
+}
+function filterFileTypesByPurpose(types, purpose) {
+    if (!purpose) {
+        return types;
+    }
+    return types.filter((type) => fileTypeMatchesPurpose(type, purpose));
+}
+function createFileTypeMetadata(purpose) {
+    const values = (Array.isArray(purpose) ? purpose : [purpose]).filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+    return { [AX_FILE_TYPE_METADATA_PURPOSE]: values };
+}
+
 /** Resolves clipboard/plain text from a copy result. */
 function resolveFileCopyText(result) {
     if (result == null) {
@@ -70,18 +103,6 @@ function resolveFileCopyText(result) {
     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) {
@@ -94,7 +115,7 @@ function mergeFileValidations(base, override) {
         rules: override.rules ?? base.rules,
     };
 }
-/** Resolved validations for a type + optional extension. */
+/** Resolved validations for a type + optional extension entry. */
 function resolveFileValidations(type, extension) {
     return mergeFileValidations(type.validations ?? {}, extension?.validations);
 }
@@ -120,13 +141,196 @@ function getFileExtension(fileName) {
     const parts = fileName.trim().split('.');
     return parts.length > 1 ? (parts.pop()?.toLowerCase() ?? '') : '';
 }
+
+/** Resolves a {@link AXFileTypeComponent} to an Angular component type. */
+async function resolveFileTypeComponentType(component) {
+    if (isLazyFileTypeComponentLoader(component)) {
+        return component();
+    }
+    return component;
+}
+/** Whether `value` is a lazy loader rather than an Angular component class. */
+function isLazyFileTypeComponentLoader(value) {
+    return typeof value === 'function' && !('ɵcmp' in value);
+}
+
+/** Matches a MIME type against a catalog pattern (`image/*`, exact type, …). */
+function matchesFileMime(mime, pattern) {
+    const normalizedMime = mime.trim().toLowerCase();
+    const normalizedPattern = pattern.trim().toLowerCase();
+    if (!normalizedPattern || normalizedPattern === '*/*' || normalizedPattern === '*') {
+        return true;
+    }
+    if (normalizedPattern.endsWith('/*')) {
+        const category = normalizedPattern.slice(0, -2);
+        return normalizedMime.startsWith(`${category}/`) || (normalizedMime === '' && category === 'application');
+    }
+    return normalizedMime === normalizedPattern;
+}
+/** Finds an extension entry by its `name` (without dot). */
+function findFileTypeExtensionByName(type, extensionName) {
+    const ext = extensionName.replace(/^\./, '').trim().toLowerCase();
+    if (!ext || !type.extensions?.length) {
+        return undefined;
+    }
+    return type.extensions.find((entry) => entry.name.toLowerCase() === ext);
+}
+/** Finds an extension entry whose validations include the given MIME type. */
+function findFileTypeExtensionForMime(type, mimeType) {
+    const mime = mimeType.trim().toLowerCase();
+    if (!mime || !type.extensions?.length) {
+        return undefined;
+    }
+    return type.extensions.find((entry) => entry.validations?.mimeTypes?.some((pattern) => matchesFileMime(mime, pattern)));
+}
 /** 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 resolveFileTypeExtension(type, { file });
+}
+/** Resolves the best-matching extension entry for a file or hint. */
+function resolveFileTypeExtension(type, hint) {
+    if (!hint) {
+        return undefined;
+    }
+    if (hint.file) {
+        const byFileName = findFileTypeExtensionByName(type, getFileExtension(hint.file.name));
+        if (byFileName) {
+            return byFileName;
+        }
+        if (hint.file.type) {
+            const byFileMime = findFileTypeExtensionForMime(type, hint.file.type);
+            if (byFileMime) {
+                return byFileMime;
+            }
+        }
+    }
+    if (hint.extensionName) {
+        const byName = findFileTypeExtensionByName(type, hint.extensionName);
+        if (byName) {
+            return byName;
+        }
+    }
+    if (hint.mimeType) {
+        return findFileTypeExtensionForMime(type, hint.mimeType);
+    }
+    return undefined;
+}
+function resolveFileTypeCopy(type, extension) {
+    return extension?.copy ?? type.copy;
+}
+function resolveFileTypeOpen(type, extension) {
+    return extension?.open ?? type.open;
+}
+function resolveFileTypeComponent(type, extension) {
+    return extension?.component ?? type.component;
+}
+/** Loads the resolved view component (extension override first). */
+async function loadFileTypeComponent(type, extension) {
+    const component = resolveFileTypeComponent(type, extension);
+    if (!component) {
+        return undefined;
+    }
+    return resolveFileTypeComponentType(component);
+}
+function resolveFileTypePaste(type, extension) {
+    return extension?.paste ?? type.paste;
+}
+function resolveFileTypeUtility(type, extension, name) {
+    const fromExtension = extension?.utilities?.[name];
+    if (fromExtension) {
+        return fromExtension;
+    }
+    return type.utilities?.[name];
+}
+/** Runs `copy` from extension first, then parent type. */
+async function runFileTypeCopy(type, payload, extension) {
+    const copy = resolveFileTypeCopy(type, extension);
+    if (!copy) {
+        return undefined;
+    }
+    return copy(payload);
+}
+/** Runs a utility from extension first, then parent type. */
+function runFileTypeUtility(type, ctx, extension, name, ...args) {
+    const utility = resolveFileTypeUtility(type, extension, name);
+    if (!utility) {
         return undefined;
     }
-    return type.extensions.find((e) => e.name.toLowerCase() === ext);
+    return utility(ctx, ...args);
+}
+/** Runs a catalog utility with optional file-based extension resolution. */
+function runFileTypeUtilityForFile(type, ctx, file, name, ...args) {
+    const extension = file ? findFileTypeExtension(file, type) : undefined;
+    return runFileTypeUtility(type, ctx, extension, name, ...args);
+}
+
+/** Runs `open` from extension first, then parent type, in the caller's injection context. */
+function runFileTypeOpen(type, ctx, payload, extension) {
+    const open = resolveFileTypeOpen(type, extension);
+    if (!open) {
+        return false;
+    }
+    return runInInjectionContext(ctx.injector, () => open(ctx, payload));
+}
+
+/**
+
+ * Builds an {@link AXFileType} with optional typed handlers and view component.
+
+ *
+
+ * @example
+
+ * ```ts
+
+ * export const imageFileType = defineFileType<ImagePayload>({
+
+ *   name: 'image',
+
+ *   copy: (p) => p.caption ?? p.url,
+
+ *   component: () => import('./image-viewer.component').then(m => m.ImageViewerComponent),
+
+ * });
+
+ * ```
+
+ */
+function defineFileType(config) {
+    const { copy, open, ...rest } = config;
+    return {
+        ...rest,
+        ...(copy ? { copy: copy } : {}),
+        ...(open ? { open: open } : {}),
+    };
+}
+
+/** 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,
+    };
+}
+
+/** Registers static file types via the existing {@link AXFileTypeInfoProvider} multi-token. */
+function provideFileTypes(types) {
+    class AXStaticFileTypeProvider extends AXFileTypeInfoProvider {
+        items() {
+            const value = typeof types === 'function' ? types() : types;
+            return Promise.resolve(value);
+        }
+        static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXStaticFileTypeProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+        static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXStaticFileTypeProvider }); }
+    }
+    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXStaticFileTypeProvider, decorators: [{
+                type: Injectable
+            }] });
+    return provideFileTypeInfoProvider(AXStaticFileTypeProvider);
 }
 
 /** Maps {@link AXFileValidations} to executable validation entries. */
@@ -229,13 +433,32 @@ class AXFileTypeRegistryService {
         this.cache = [...byName.values()];
         return this.cache;
     }
-    async getTypes() {
-        return this.resolveTypes();
+    async getTypes(query) {
+        const types = await this.resolveTypes();
+        return filterFileTypesByPurpose(types, query?.purpose);
     }
     async get(name) {
         const types = await this.resolveTypes();
         return types.find((t) => t.name === name);
     }
+    /** Resolved view component ref for a catalog entry (optional extension hint). */
+    async getComponent(name, hint) {
+        const type = await this.get(name);
+        if (!type) {
+            return undefined;
+        }
+        const extension = hint ? resolveFileTypeExtension(type, hint) : undefined;
+        return resolveFileTypeComponent(type, extension);
+    }
+    /** Loads the view component for a catalog entry. */
+    async loadComponent(name, hint) {
+        const type = await this.get(name);
+        if (!type) {
+            return undefined;
+        }
+        const extension = hint ? resolveFileTypeExtension(type, hint) : undefined;
+        return loadFileTypeComponent(type, extension);
+    }
     async accept(typeNames) {
         const names = typeNames ? (Array.isArray(typeNames) ? typeNames : [typeNames]) : undefined;
         const types = await this.resolveTypes();
@@ -264,7 +487,7 @@ class AXFileTypeRegistryService {
             if (!patterns.length) {
                 return false;
             }
-            return patterns.some((pattern) => this.matchesMime(mime, pattern.trim().toLowerCase()));
+            return patterns.some((pattern) => matchesFileMime(mime, pattern));
         });
     }
     async validate(file, typeName) {
@@ -308,16 +531,6 @@ class AXFileTypeRegistryService {
         }
         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' }); }
 }
@@ -326,9 +539,58 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+class AXFileTypeRendererOutletComponent {
+    constructor() {
+        this.registry = inject(AXFileTypeRegistryService);
+        /** Catalog name (e.g. `image`, `conversation-image`). */
+        this.fileType = input.required(...(ngDevMode ? [{ debugName: "fileType" }] : /* istanbul ignore next */ []));
+        /** Payload passed to the file-type view component. */
+        this.payload = input.required(...(ngDevMode ? [{ debugName: "payload" }] : /* istanbul ignore next */ []));
+        /** Optional extension / MIME hint for extension-level renderer overrides. */
+        this.extensionHint = input(...(ngDevMode ? [undefined, { debugName: "extensionHint" }] : /* istanbul ignore next */ []));
+        /** Extra inputs merged with `payload` (e.g. `message` in conversation). */
+        this.inputs = input({}, ...(ngDevMode ? [{ debugName: "inputs" }] : /* istanbul ignore next */ []));
+        this.resolvedComponent = signal(null, ...(ngDevMode ? [{ debugName: "resolvedComponent" }] : /* istanbul ignore next */ []));
+        this.loading = signal(false, ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+        this.mergedInputs = signal({}, ...(ngDevMode ? [{ debugName: "mergedInputs" }] : /* istanbul ignore next */ []));
+        effect(() => {
+            const name = this.fileType();
+            const payload = this.payload();
+            const hint = this.extensionHint();
+            const extra = this.inputs();
+            this.mergedInputs.set({ payload, ...extra });
+            this.loading.set(true);
+            this.resolvedComponent.set(null);
+            void this.registry.loadComponent(name, hint).then((component) => {
+                this.resolvedComponent.set(component ?? null);
+                this.loading.set(false);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileTypeRendererOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXFileTypeRendererOutletComponent, isStandalone: true, selector: "ax-file-type-renderer", inputs: { fileType: { classPropertyName: "fileType", publicName: "fileType", isSignal: true, isRequired: true, transformFunction: null }, payload: { classPropertyName: "payload", publicName: "payload", isSignal: true, isRequired: true, transformFunction: null }, extensionHint: { classPropertyName: "extensionHint", publicName: "extensionHint", isSignal: true, isRequired: false, transformFunction: null }, inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    @if (resolvedComponent(); as component) {
+      <ng-container *ngComponentOutlet="component; inputs: mergedInputs()" />
+    } @else if (loading()) {
+      <span class="ax-file-type-renderer__loading" aria-hidden="true"></span>
+    }
+  `, isInline: true, styles: [":host{display:contents}.ax-file-type-renderer__loading{display:inline-block;min-height:1rem;min-width:1rem}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXFileTypeRendererOutletComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ax-file-type-renderer', changeDetection: ChangeDetectionStrategy.OnPush, imports: [NgComponentOutlet], template: `
+    @if (resolvedComponent(); as component) {
+      <ng-container *ngComponentOutlet="component; inputs: mergedInputs()" />
+    } @else if (loading()) {
+      <span class="ax-file-type-renderer__loading" aria-hidden="true"></span>
+    }
+  `, styles: [":host{display:contents}.ax-file-type-renderer__loading{display:inline-block;min-height:1rem;min-width:1rem}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { fileType: [{ type: i0.Input, args: [{ isSignal: true, alias: "fileType", required: true }] }], payload: [{ type: i0.Input, args: [{ isSignal: true, alias: "payload", required: true }] }], extensionHint: [{ type: i0.Input, args: [{ isSignal: true, alias: "extensionHint", required: false }] }], inputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputs", required: false }] }] } });
+
 const MB$4 = 1024 * 1024;
 const AX_AUDIO_FILE_TYPE = {
     name: 'audio',
+    metadata: createFileTypeMetadata('system'),
     title: 'Audio',
     icon: 'fa-light fa-music ax-text-amber-500',
     validations: {
@@ -358,6 +620,7 @@ const MB$3 = 1024 * 1024;
 /** Extension-only: no type `validations` — only listed extensions are allowed. */
 const AX_DOCUMENT_FILE_TYPE = {
     name: 'document',
+    metadata: createFileTypeMetadata('system'),
     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 } }],
@@ -376,6 +639,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 const MB$2 = 1024 * 1024;
 const AX_FILE_FILE_TYPE = {
     name: 'file',
+    metadata: createFileTypeMetadata('system'),
     title: 'File',
     icon: 'fa-light fa-file ax-text-neutral-500',
     validations: {
@@ -405,6 +669,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 const MB$1 = 1024 * 1024;
 const AX_IMAGE_FILE_TYPE = {
     name: 'image',
+    metadata: createFileTypeMetadata('system'),
     title: 'Image',
     icon: 'fa-light fa-image ax-text-purple-500',
     validations: {
@@ -435,6 +700,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 const MB = 1024 * 1024;
 const AX_VIDEO_FILE_TYPE = {
     name: 'video',
+    metadata: createFileTypeMetadata('system'),
     title: 'Video',
     icon: 'fa-light fa-video ax-text-blue-500',
     validations: {
@@ -736,5 +1002,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
  * 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_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 };
+export { AXAudioFileTypeProvider, AXDocumentFileTypeProvider, AXFileFileTypeProvider, AXFileMaxSizeValidationRule, AXFileMimeTypeValidationRule, AXFileMinSizeValidationRule, AXFileModule, AXFileService, AXFileSizeFormatter, AXFileTypeInfoProvider, AXFileTypeRegistryService, AXFileTypeRendererOutletComponent, 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_METADATA_PURPOSE, AX_FILE_VALIDATION_RULES, AX_IMAGE_FILE_TYPE, AX_VIDEO_FILE_TYPE, createFileTypeMetadata, defineFileType, fileTypeMatchesPurpose, fileValidationsToRules, filterFileTypesByPurpose, findFileTypeExtension, findFileTypeExtensionByName, findFileTypeExtensionForMime, formatFileSizeBytes, getFileExtension, getFileTypePurposes, isEmptyFileValidations, isExtensionsOnlyType, isLazyFileTypeComponentLoader, loadFileTypeComponent, matchesFileMime, mergeFileValidations, provideBuiltinFileTypeProviders, provideDefaultFileTypeProviders, provideFileTypeInfoProvider, provideFileTypeSystem, provideFileTypes, provideFileValidationRules, resolveFileCopyText, resolveFileTypeComponent, resolveFileTypeComponentType, resolveFileTypeCopy, resolveFileTypeExtension, resolveFileTypeOpen, resolveFileTypePaste, resolveFileTypeUtility, resolveFileValidations, runFileTypeCopy, runFileTypeOpen, runFileTypeUtility, runFileTypeUtilityForFile, validateFileAgainstType, validateFileWithValidations };
 //# sourceMappingURL=acorex-core-file.mjs.map