@streamscloud/kit 0.9.13 → 0.9.15

package/dist/core/data-loaders/cursor-data-loader-with-search.svelte.d.ts

@@ -5,7 +5,8 @@ export declare class CursorDataLoaderWithSearch<T> implements IDataLoader<T> {
     private continuationToken;
     private _searchString;
     private loadPage;
-    private deferred;
+    private pending;
+    private generation;
     private searchStringMinLength;
     constructor(init: {
         loadPage: (continuationToken: ContinuationToken, searchString: string) => Promise<CursorResult<T> | null>;
@@ -15,5 +16,6 @@ export declare class CursorDataLoaderWithSearch<T> implements IDataLoader<T> {
     loadMore: () => Promise<T[]>;
     reset(): Promise<void>;
     updateSearchString: (searchString: string | null) => void;
+    private runLoad;
     private isSearchStringEffective;
 }

package/dist/core/data-loaders/cursor-data-loader-with-search.svelte.js

@@ -1,11 +1,12 @@
-import { ContinuationToken, Deferred } from '..';
+import { ContinuationToken } from '..';
 import { Utils } from '../utils';
 export class CursorDataLoaderWithSearch {
     items = $state.raw([]);
     continuationToken = $state.raw(ContinuationToken.init());
     _searchString = $state.raw('');
     loadPage;
-    deferred = null;
+    pending = null;
+    generation = 0;
     searchStringMinLength = 1;
     constructor(init) {
         this.loadPage = init.loadPage;
@@ -18,25 +19,27 @@ export class CursorDataLoaderWithSearch {
         return this._searchString;
     }
     loadMore = async () => {
-        if (this.deferred) {
-            return this.deferred.promise;
+        if (this.pending) {
+            return this.pending;
         }
         if (!this.continuationToken.canLoadMore) {
             return [];
         }
-        this.deferred = new Deferred();
-        const search = this.isSearchStringEffective(this._searchString) ? this._searchString : '';
-        let result = await this.loadPage(this.continuationToken, search);
-        if (!result) {
-            result = { items: [], continuationToken: ContinuationToken.preventLoading() };
-        }
-        this.continuationToken = result.continuationToken;
-        this.items = [...this.items, ...result.items];
-        this.deferred.resolve(result.items);
-        this.deferred = null;
-        return result.items;
+        const pending = this.runLoad();
+        this.pending = pending;
+        try {
+            return await pending;
+        }
+        finally {
+            // a concurrent reset() may have installed a newer load — leave that one alone
+            if (this.pending === pending) {
+                this.pending = null;
+            }
+        }
     };
     async reset() {
+        this.generation++;
+        this.pending = null;
         this.items = [];
         this.continuationToken = ContinuationToken.init();
         await this.loadMore();
@@ -50,7 +53,25 @@ export class CursorDataLoaderWithSearch {
         const isEffective = this.isSearchStringEffective(newValue);
         this._searchString = newValue;
         if (wasEffective || isEffective) {
-            this.reset();
+            void this.reset();
+        }
+    };
+    runLoad = async () => {
+        const generation = this.generation;
+        const search = this.isSearchStringEffective(this._searchString) ? this._searchString : '';
+        try {
+            const result = (await this.loadPage(this.continuationToken, search)) ?? { items: [], continuationToken: ContinuationToken.preventLoading() };
+            // a reset() mid-load bumps the generation — drop the stale page instead of appending it to the cleared list
+            if (generation !== this.generation) {
+                return [];
+            }
+            this.continuationToken = result.continuationToken;
+            this.items = [...this.items, ...result.items];
+            return result.items;
+        }
+        catch (error) {
+            console.error('CursorDataLoaderWithSearch: failed to load page', error);
+            return [];
         }
     };
     isSearchStringEffective = (searchString) => searchString && searchString.length >= this.searchStringMinLength;

package/dist/core/data-loaders/cursor-data-loader.svelte.d.ts

@@ -4,10 +4,12 @@ export declare class CursorDataLoader<T> implements IDataLoader<T> {
     items: T[];
     continuationToken: ContinuationToken;
     private loadPage;
-    private deferred;
+    private pending;
+    private generation;
     constructor(init: {
         loadPage: (continuationToken: ContinuationToken) => Promise<CursorResult<T> | null>;
     });
     loadMore: () => Promise<T[]>;
     reset(): Promise<void>;
+    private runLoad;
 }

package/dist/core/data-loaders/cursor-data-loader.svelte.js

@@ -1,33 +1,54 @@
-import { ContinuationToken, Deferred } from '..';
+import { ContinuationToken } from '..';
 export class CursorDataLoader {
     items = $state.raw([]);
     continuationToken = $state.raw(ContinuationToken.init());
     loadPage;
-    deferred = null;
+    pending = null;
+    generation = 0;
     constructor(init) {
         this.loadPage = init.loadPage;
     }
     loadMore = async () => {
-        if (this.deferred) {
-            return this.deferred.promise;
+        if (this.pending) {
+            return this.pending;
         }
         if (!this.continuationToken.canLoadMore) {
             return [];
         }
-        this.deferred = new Deferred();
-        let result = await this.loadPage(this.continuationToken);
-        if (!result) {
-            result = { items: [], continuationToken: ContinuationToken.preventLoading() };
+        const pending = this.runLoad();
+        this.pending = pending;
+        try {
+            return await pending;
+        }
+        finally {
+            // a concurrent reset() may have installed a newer load — leave that one alone
+            if (this.pending === pending) {
+                this.pending = null;
+            }
         }
-        this.continuationToken = result.continuationToken;
-        this.items = [...this.items, ...result.items];
-        this.deferred.resolve(result.items);
-        this.deferred = null;
-        return result.items;
     };
     async reset() {
+        this.generation++;
+        this.pending = null;
         this.items = [];
         this.continuationToken = ContinuationToken.init();
         await this.loadMore();
     }
+    runLoad = async () => {
+        const generation = this.generation;
+        try {
+            const result = (await this.loadPage(this.continuationToken)) ?? { items: [], continuationToken: ContinuationToken.preventLoading() };
+            // a reset() mid-load bumps the generation — drop the stale page instead of appending it to the cleared list
+            if (generation !== this.generation) {
+                return [];
+            }
+            this.continuationToken = result.continuationToken;
+            this.items = [...this.items, ...result.items];
+            return result.items;
+        }
+        catch (error) {
+            console.error('CursorDataLoader: failed to load page', error);
+            return [];
+        }
+    };
 }

package/dist/core/files/file-types.d.ts

@@ -13,4 +13,8 @@ export declare class AcceptFileType {
     static readonly webAssetImageOrVideo: string;
     static readonly webAssetIcon = "image/png";
 }
+/**
+ * `accept`-style matcher. Tokens may be MIMEs (`image/*`, `*\/*`, `application/pdf`) or
+ * extensions (`.pdf`), case-insensitive. Empty accept = match anything.
+ */
 export declare const matchesAcceptedFileTypes: (file: File, acceptedTypesAndExtensions: string) => boolean;

package/dist/core/files/file-types.js

@@ -1,4 +1,3 @@
-import { FileHelper } from './file-helper';
 export class AcceptFileType {
     static any = '*/*';
     static image = 'image/png,image/jpeg,image/webp';
@@ -15,14 +14,30 @@ export class AcceptFileType {
     static webAssetImageOrVideo = [this.webAssetImage, this.webAssetVideo].join(',');
     static webAssetIcon = 'image/png';
 }
+/**
+ * `accept`-style matcher. Tokens may be MIMEs (`image/*`, `*\/*`, `application/pdf`) or
+ * extensions (`.pdf`), case-insensitive. Empty accept = match anything.
+ */
 export const matchesAcceptedFileTypes = (file, acceptedTypesAndExtensions) => {
-    const isValid = AcceptFileType.anySupported.split(',').includes(file.type);
-    if (acceptedTypesAndExtensions) {
-        const acceptanceArray = acceptedTypesAndExtensions.split(',');
-        const extensions = acceptanceArray.filter((x) => x.startsWith('.'));
-        const fileExt = '.' + FileHelper.getFileExtension(file.name);
-        const fileTypes = acceptanceArray.filter((x) => !x.startsWith('.'));
-        return (extensions.includes(fileExt) || fileTypes.includes(file.type)) && isValid;
+    const tokens = acceptedTypesAndExtensions
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return true;
     }
-    return isValid;
+    const fileType = (file.type || '').toLowerCase();
+    const fileName = file.name.toLowerCase();
+    return tokens.some((token) => {
+        if (token.startsWith('.')) {
+            return fileName.endsWith(token);
+        }
+        if (token === '*/*') {
+            return true;
+        }
+        if (token.endsWith('/*')) {
+            return fileType.startsWith(token.slice(0, -1));
+        }
+        return fileType === token;
+    });
 };

package/dist/core/files/file-validation-localization.d.ts

@@ -0,0 +1,12 @@
+export declare class FileValidationLocalization {
+    get invalidFile(): string;
+    get unsupportedType(): string;
+    get audioOnly(): string;
+    get maxSize(): (size: string) => string;
+    get extensions(): (list: string) => string;
+    get maxDimensions(): (width: number, height: number) => string;
+    get minDimensions(): (width: number, height: number) => string;
+    get maxDuration(): (seconds: number) => string;
+    get aspectRatio(): (ratios: string) => string;
+    get maxBitrate(): (kbps: number) => string;
+}

package/dist/core/files/file-validation-localization.js

@@ -0,0 +1,75 @@
+import { AppLocale } from '../locale';
+export class FileValidationLocalization {
+    get invalidFile() {
+        return loc.invalidFile[AppLocale.current];
+    }
+    get unsupportedType() {
+        return loc.unsupportedType[AppLocale.current];
+    }
+    get audioOnly() {
+        return loc.audioOnly[AppLocale.current];
+    }
+    get maxSize() {
+        return loc.maxSize[AppLocale.current];
+    }
+    get extensions() {
+        return loc.extensions[AppLocale.current];
+    }
+    get maxDimensions() {
+        return loc.maxDimensions[AppLocale.current];
+    }
+    get minDimensions() {
+        return loc.minDimensions[AppLocale.current];
+    }
+    get maxDuration() {
+        return loc.maxDuration[AppLocale.current];
+    }
+    get aspectRatio() {
+        return loc.aspectRatio[AppLocale.current];
+    }
+    get maxBitrate() {
+        return loc.maxBitrate[AppLocale.current];
+    }
+}
+const loc = {
+    invalidFile: {
+        en: 'Invalid file',
+        no: 'Ugyldig fil'
+    },
+    unsupportedType: {
+        en: 'Unsupported file type',
+        no: 'Filtypen støttes ikke'
+    },
+    audioOnly: {
+        en: 'Audio files only',
+        no: 'Kun lydfiler'
+    },
+    maxSize: {
+        en: (size) => `Maximum file size: ${size}`,
+        no: (size) => `Maks filstørrelse: ${size}`
+    },
+    extensions: {
+        en: (list) => `Allowed file types: ${list}`,
+        no: (list) => `Tillatte filtyper: ${list}`
+    },
+    maxDimensions: {
+        en: (width, height) => `Maximum dimensions: ${width}×${height}px`,
+        no: (width, height) => `Maks oppløsning: ${width}×${height}px`
+    },
+    minDimensions: {
+        en: (width, height) => `Minimum dimensions: ${width}×${height}px`,
+        no: (width, height) => `Min oppløsning: ${width}×${height}px`
+    },
+    maxDuration: {
+        en: (seconds) => `Maximum duration: ${seconds}s`,
+        no: (seconds) => `Maks varighet: ${seconds}s`
+    },
+    aspectRatio: {
+        en: (ratios) => `Allowed aspect ratio: ${ratios}`,
+        no: (ratios) => `Tillatt sideforhold: ${ratios}`
+    },
+    maxBitrate: {
+        en: (kbps) => `Maximum bitrate: ${kbps} kbps`,
+        no: (kbps) => `Maks bitrate: ${kbps} kbps`
+    }
+};

package/dist/core/files/file-validation-rule-sets.d.ts

@@ -0,0 +1,8 @@
+import type { FileValidationRule, FileValidationRuleSets } from './file-validation-types';
+export declare const toRuleSets: (rules: FileValidationRule[] | FileValidationRuleSets) => FileValidationRuleSets;
+/**
+ * Union of every rule's `accept` across all sets, de-duplicated — the native picker filter /
+ * drag-over hint a containing cmp shows so a file matching any set can be selected.
+ */
+export declare const deriveAccept: (rules: FileValidationRule[] | FileValidationRuleSets) => string;
+export declare const pickRuleSet: (file: File, sets: FileValidationRuleSets) => FileValidationRule[] | null;

package/dist/core/files/file-validation-rule-sets.js

@@ -0,0 +1,24 @@
+import { matchesAcceptedFileTypes } from './file-types';
+const isRuleSets = (rules) => Array.isArray(rules[0]);
+export const toRuleSets = (rules) => rules.length === 0 ? [] : isRuleSets(rules) ? rules : [rules];
+const acceptTokens = (set) => set
+    .flatMap((rule) => (rule.accept ? rule.accept.split(',') : []))
+    .map((token) => token.trim())
+    .filter(Boolean);
+/**
+ * Union of every rule's `accept` across all sets, de-duplicated — the native picker filter /
+ * drag-over hint a containing cmp shows so a file matching any set can be selected.
+ */
+export const deriveAccept = (rules) => {
+    const tokens = toRuleSets(rules).flatMap(acceptTokens);
+    return [...new Set(tokens)].join(',');
+};
+export const pickRuleSet = (file, sets) => {
+    for (const set of sets) {
+        const accept = acceptTokens(set).join(',');
+        if (!accept || matchesAcceptedFileTypes(file, accept)) {
+            return set;
+        }
+    }
+    return null;
+};

package/dist/core/files/file-validation-rules.d.ts

@@ -1,30 +1,39 @@
 import type { FileValidationRule } from './file-validation-types';
 /**
- * Built-in rule factories. Each takes a constraint plus the consumer-supplied localized message
- * — kit never ships English error strings. Returned rule is a callable function; the `Mime`
- * factory additionally attaches `.accept` so containing UI cmps (`FileUploader`,
- * `OpenFileButton`) can auto-derive the native picker filter / drag-over hint.
+ * Built-in rule factories. Each takes a constraint and an optional `message`; when omitted, the
+ * rule falls back to a localized default from `FileValidationLocalization` (kit ships no English
+ * literals — defaults follow `AppLocale`). The `Mime` factory additionally attaches `.accept` so
+ * containing UI cmps (`FileUploader`, `OpenFileButton`) can auto-derive the native picker filter /
+ * drag-over hint.
  *
  * @example
  * ```ts
  * const rules = [
- *   FileRules.Mime('image/*', 'Please pick an image.'),
+ *   FileRules.Mime('image/*'),
  *   FileRules.MaxSize(5 * 1024 * 1024, 'Image must be under 5 MB.')
  * ];
  * const results = await FileValidator.validateMany(files, rules);
  * ```
  */
 export declare const FileRules: {
-    MaxSize: (bytes: number, message: string) => FileValidationRule;
-    Mime: (accept: string, message: string) => FileValidationRule;
+    AudioBitrate: (maxKbps: number, message?: string) => FileValidationRule;
+    AudioDuration: (maxSeconds: number, message?: string) => FileValidationRule;
+    AudioOnly: (message?: string) => FileValidationRule;
+    Extensions: (extensions: string[], message?: string) => FileValidationRule;
     ImageDimensions: (max: {
         width: number;
         height: number;
-    }, message: string) => FileValidationRule;
+    }, message?: string) => FileValidationRule;
     ImageMinDimensions: (min: {
         width: number;
         height: number;
-    }, message: string) => FileValidationRule;
-    AudioDuration: (maxSeconds: number, message: string) => FileValidationRule;
-    VideoDuration: (maxSeconds: number, message: string) => FileValidationRule;
+    }, message?: string) => FileValidationRule;
+    MaxSize: (bytes: number, message?: string) => FileValidationRule;
+    Mime: (accept: string, message?: string) => FileValidationRule;
+    VideoAspectRatio: (ratios: string[], message?: string, tolerancePercent?: number) => FileValidationRule;
+    VideoDimensions: (max: {
+        width: number;
+        height: number;
+    }, message?: string) => FileValidationRule;
+    VideoDuration: (maxSeconds: number, message?: string) => FileValidationRule;
 };

package/dist/core/files/file-validation-rules.js

@@ -1,32 +1,7 @@
-/**
- * Permissive `accept`-style matcher. Tokens may be MIMEs (`image/*`, `application/pdf`) or
- * extensions (`.pdf`). Empty accept = match anything. Unlike `matchesAcceptedFileTypes` from
- * `./file-types`, this does NOT cross-check against an internal whitelist — only the
- * consumer's accept string drives the decision.
- */
-const matchesAccept = (file, accept) => {
-    if (!accept) {
-        return true;
-    }
-    const tokens = accept
-        .split(',')
-        .map((s) => s.trim().toLowerCase())
-        .filter(Boolean);
-    if (tokens.length === 0) {
-        return true;
-    }
-    const fileType = (file.type || '').toLowerCase();
-    const fileName = file.name.toLowerCase();
-    return tokens.some((t) => {
-        if (t.startsWith('.')) {
-            return fileName.endsWith(t);
-        }
-        if (t.endsWith('/*')) {
-            return fileType.startsWith(t.slice(0, -1));
-        }
-        return fileType === t;
-    });
-};
+import { StringHelper } from '../utils';
+import { FileHelper } from './file-helper';
+import { matchesAcceptedFileTypes } from './file-types';
+import { FileValidationLocalization } from './file-validation-localization';
 const readImageDimensions = (file) => new Promise((resolve, reject) => {
     const url = URL.createObjectURL(file);
     const img = new Image();
@@ -54,42 +29,96 @@ const readMediaDuration = (file, kind) => new Promise((resolve, reject) => {
     };
     el.src = url;
 });
+const readVideoDimensions = (file) => new Promise((resolve, reject) => {
+    const url = URL.createObjectURL(file);
+    const video = document.createElement('video');
+    video.preload = 'metadata';
+    video.onloadedmetadata = () => {
+        URL.revokeObjectURL(url);
+        resolve({ width: video.videoWidth, height: video.videoHeight });
+    };
+    video.onerror = () => {
+        URL.revokeObjectURL(url);
+        reject(new Error('Failed to read video dimensions'));
+    };
+    video.src = url;
+});
+const parseRatio = (ratio) => {
+    const [w, h] = ratio.split(':').map((part) => parseFloat(part));
+    return h ? w / h : NaN;
+};
+const formatExtensions = (extensions) => extensions.map((ext) => '.' + ext.replace(/^\./, '')).join(', ');
+const messages = new FileValidationLocalization();
 /**
- * Built-in rule factories. Each takes a constraint plus the consumer-supplied localized message
- * — kit never ships English error strings. Returned rule is a callable function; the `Mime`
- * factory additionally attaches `.accept` so containing UI cmps (`FileUploader`,
- * `OpenFileButton`) can auto-derive the native picker filter / drag-over hint.
+ * Built-in rule factories. Each takes a constraint and an optional `message`; when omitted, the
+ * rule falls back to a localized default from `FileValidationLocalization` (kit ships no English
+ * literals — defaults follow `AppLocale`). The `Mime` factory additionally attaches `.accept` so
+ * containing UI cmps (`FileUploader`, `OpenFileButton`) can auto-derive the native picker filter /
+ * drag-over hint.
  *
  * @example
  * ```ts
  * const rules = [
- *   FileRules.Mime('image/*', 'Please pick an image.'),
+ *   FileRules.Mime('image/*'),
  *   FileRules.MaxSize(5 * 1024 * 1024, 'Image must be under 5 MB.')
  * ];
  * const results = await FileValidator.validateMany(files, rules);
  * ```
  */
 export const FileRules = {
-    MaxSize: (bytes, message) => (file) => file.size > bytes ? message : null,
-    Mime: (accept, message) => {
-        const rule = (file) => (matchesAccept(file, accept) ? null : message);
-        rule.accept = accept;
-        return rule;
+    AudioBitrate: (maxKbps, message) => async (file) => {
+        const duration = await readMediaDuration(file, 'audio');
+        if (!duration) {
+            return null;
+        }
+        const kbps = (file.size * 8) / duration / 1000;
+        return kbps > maxKbps ? (message ?? messages.maxBitrate(maxKbps)) : null;
+    },
+    AudioDuration: (maxSeconds, message) => async (file) => {
+        const duration = await readMediaDuration(file, 'audio');
+        return duration > maxSeconds ? (message ?? messages.maxDuration(maxSeconds)) : null;
+    },
+    AudioOnly: (message) => async (file) => {
+        const { width, height } = await readVideoDimensions(file);
+        return width > 0 || height > 0 ? (message ?? messages.audioOnly) : null;
+    },
+    Extensions: (extensions, message) => (file) => {
+        const extension = FileHelper.getFileExtension(file.name).toLowerCase();
+        const allowed = extensions.map((ext) => ext.replace(/^\./, '').toLowerCase());
+        return allowed.includes(extension) ? null : (message ?? messages.extensions(formatExtensions(extensions)));
     },
     ImageDimensions: (max, message) => async (file) => {
         const { width, height } = await readImageDimensions(file);
-        return width > max.width || height > max.height ? message : null;
+        return width > max.width || height > max.height ? (message ?? messages.maxDimensions(max.width, max.height)) : null;
     },
     ImageMinDimensions: (min, message) => async (file) => {
         const { width, height } = await readImageDimensions(file);
-        return width < min.width || height < min.height ? message : null;
+        return width < min.width || height < min.height ? (message ?? messages.minDimensions(min.width, min.height)) : null;
     },
-    AudioDuration: (maxSeconds, message) => async (file) => {
-        const duration = await readMediaDuration(file, 'audio');
-        return duration > maxSeconds ? message : null;
+    MaxSize: (bytes, message) => (file) => file.size > bytes ? (message ?? messages.maxSize(StringHelper.toFileSizeString(bytes))) : null,
+    Mime: (accept, message) => {
+        const rule = (file) => (matchesAcceptedFileTypes(file, accept) ? null : (message ?? messages.unsupportedType));
+        rule.accept = accept;
+        return rule;
+    },
+    VideoAspectRatio: (ratios, message, tolerancePercent = 1) => async (file) => {
+        const { width, height } = await readVideoDimensions(file);
+        if (!width || !height) {
+            return message ?? messages.aspectRatio(ratios.join(', '));
+        }
+        const actual = width / height;
+        const matches = ratios.some((ratio) => {
+            const target = parseRatio(ratio);
+            return Number.isFinite(target) && Math.abs((actual / target) * 100 - 100) <= tolerancePercent;
+        });
+        return matches ? null : (message ?? messages.aspectRatio(ratios.join(', ')));
+    },
+    VideoDimensions: (max, message) => async (file) => {
+        const { width, height } = await readVideoDimensions(file);
+        return width > max.width || height > max.height ? (message ?? messages.maxDimensions(max.width, max.height)) : null;
     },
     VideoDuration: (maxSeconds, message) => async (file) => {
         const duration = await readMediaDuration(file, 'video');
-        return duration > maxSeconds ? message : null;
+        return duration > maxSeconds ? (message ?? messages.maxDuration(maxSeconds)) : null;
     }
 };

package/dist/core/files/file-validation-types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Single async validation rule. Returns `null` (or empty array) when the file is valid,
- * a string (or array of strings) when invalid. The consumer supplies the localized message
- * when constructing the rule — kit ships only rule factories, never English defaults.
+ * a string (or array of strings) when invalid. The message is supplied by the rule factory;
+ * when omitted it falls back to a localized default (`FileValidationLocalization`).
  *
  * Optional `accept` property: when set (only the `FileRules.Mime` factory does this), the
  * containing UI cmps (`FileUploader`, `OpenFileButton`) auto-derive the native picker filter
@@ -10,6 +10,13 @@
 export type FileValidationRule = ((file: File) => string | string[] | null | Promise<string | string[] | null>) & {
     accept?: string;
 };
+/**
+ * One or more rule sets. A flat `FileValidationRule[]` is a single set applied to every file.
+ * A `FileValidationRule[][]` is several sets: per file, the first set whose `accept` matches
+ * (a set with no `accept` rule matches anything) is applied — lets one picker accept different
+ * file types with different rules. A file matching no set is rejected as an unsupported type.
+ */
+export type FileValidationRuleSets = FileValidationRule[][];
 /** Aggregate validation result for a single file across one or more rules. */
 export type FileValidationResult = {
     file: File;

package/dist/core/files/file-validator.d.ts

@@ -1,5 +1,5 @@
-import type { FileValidationResult, FileValidationRule } from './file-validation-types';
+import type { FileValidationResult, FileValidationRule, FileValidationRuleSets } from './file-validation-types';
 export declare class FileValidator {
-    static validate(file: File, rules: FileValidationRule[]): Promise<FileValidationResult>;
-    static validateMany(files: File[], rules: FileValidationRule[]): Promise<FileValidationResult[]>;
+    static validate(file: File, rules: FileValidationRule[] | FileValidationRuleSets): Promise<FileValidationResult>;
+    static validateMany(files: File[], rules: FileValidationRule[] | FileValidationRuleSets): Promise<FileValidationResult[]>;
 }

package/dist/core/files/file-validator.js

@@ -1,9 +1,23 @@
+import { FileValidationLocalization } from './file-validation-localization';
+import { pickRuleSet, toRuleSets } from './file-validation-rule-sets';
 const toArray = (v) => (v === null ? [] : Array.isArray(v) ? v : [v]);
+const messages = new FileValidationLocalization();
 export class FileValidator {
     static async validate(file, rules) {
+        const sets = toRuleSets(rules);
+        const set = sets.length > 1 ? pickRuleSet(file, sets) : (sets[0] ?? []);
+        if (set === null) {
+            return { file, isValid: false, errors: [messages.unsupportedType] };
+        }
         const errors = [];
-        for (const rule of rules) {
-            const result = await rule(file);
+        for (const rule of set) {
+            let result;
+            try {
+                result = await rule(file);
+            }
+            catch {
+                return { file, isValid: false, errors: [messages.invalidFile] };
+            }
             const msgs = toArray(result);
             if (msgs.length > 0) {
                 errors.push(...msgs);

package/dist/core/files/index.d.ts

@@ -1,5 +1,5 @@
 export type { BlobWithName, FileWithBlobUrl, FileWithUploadUrl } from './types';
-export type { FileValidationResult, FileValidationRule } from './file-validation-types';
+export type { FileValidationResult, FileValidationRule, FileValidationRuleSets } from './file-validation-types';
 export type { BlobKind, BlobKinds, BlobUpload, BlobUploadStrategy, UploadingFile, UploadingFileStatus } from './upload-types';
 export type { UploadMediaStoreOptions } from './upload-media-store.svelte';
 export { toBlobWithName, toFileWithUploadUrl } from './types';
@@ -8,6 +8,7 @@ export { openFile } from './open-file';
 export { FileHelper } from './file-helper';
 export { downloadBlob, downloadFromUrl, downloadJson, fetchFile } from './file-service';
 export { AcceptFileType, matchesAcceptedFileTypes } from './file-types';
+export { deriveAccept } from './file-validation-rule-sets';
 export { resizeBlob, resizeImage } from './image-resizer';
 export { FileWithBlobDataHelper } from './file-with-blob-data-helper';
 export { FilesProvider } from './files-provider';

package/dist/core/files/index.js

@@ -5,6 +5,7 @@ export { openFile } from './open-file';
 export { FileHelper } from './file-helper';
 export { downloadBlob, downloadFromUrl, downloadJson, fetchFile } from './file-service';
 export { AcceptFileType, matchesAcceptedFileTypes } from './file-types';
+export { deriveAccept } from './file-validation-rule-sets';
 export { resizeBlob, resizeImage } from './image-resizer';
 export { FileWithBlobDataHelper } from './file-with-blob-data-helper';
 export { FilesProvider } from './files-provider';