@streamscloud/kit 0.11.2 → 0.11.3

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

@@ -1,3 +1,4 @@
+import type { VideoOrientationValue } from './file-validation-types';
 export declare class FileValidationLocalization {
     get invalidFile(): string;
     get unsupportedType(): string;
@@ -8,5 +9,7 @@ export declare class FileValidationLocalization {
     get minDimensions(): (width: number, height: number) => string;
     get maxDuration(): (seconds: number) => string;
     get aspectRatio(): (ratios: string) => string;
+    get aspectRatioRange(): (min: string, max: string) => string;
+    get orientation(): (orientation: VideoOrientationValue) => string;
     get maxBitrate(): (kbps: number) => string;
 }

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

@@ -27,10 +27,20 @@ export class FileValidationLocalization {
     get aspectRatio() {
         return loc.aspectRatio[AppLocale.current];
     }
+    get aspectRatioRange() {
+        return loc.aspectRatioRange[AppLocale.current];
+    }
+    get orientation() {
+        return loc.orientation[AppLocale.current];
+    }
     get maxBitrate() {
         return loc.maxBitrate[AppLocale.current];
     }
 }
+const orientationLabels = {
+    en: { landscape: 'landscape', portrait: 'portrait', square: 'square' },
+    no: { landscape: 'liggende', portrait: 'stående', square: 'kvadratisk' }
+};
 const loc = {
     invalidFile: {
         en: 'Invalid file',
@@ -68,6 +78,30 @@ const loc = {
         en: (ratios) => `Allowed aspect ratio: ${ratios}`,
         no: (ratios) => `Tillatt sideforhold: ${ratios}`
     },
+    aspectRatioRange: {
+        en: (min, max) => {
+            if (min && max) {
+                return `Allowed aspect ratio: ${min}–${max}`;
+            }
+            if (min) {
+                return `Allowed aspect ratio: ${min} or wider`;
+            }
+            return `Allowed aspect ratio: up to ${max}`;
+        },
+        no: (min, max) => {
+            if (min && max) {
+                return `Tillatt sideforhold: ${min}–${max}`;
+            }
+            if (min) {
+                return `Tillatt sideforhold: ${min} eller bredere`;
+            }
+            return `Tillatt sideforhold: opptil ${max}`;
+        }
+    },
+    orientation: {
+        en: (orientation) => `Allowed orientation: ${orientationLabels.en[orientation]}`,
+        no: (orientation) => `Tillatt retning: ${orientationLabels.no[orientation]}`
+    },
     maxBitrate: {
         en: (kbps) => `Maximum bitrate: ${kbps} kbps`,
         no: (kbps) => `Maks bitrate: ${kbps} kbps`

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

@@ -1,4 +1,4 @@
-import type { FileValidationRule } from './file-validation-types';
+import type { AspectRatioBound, FileValidationRule, VideoOrientationValue } from './file-validation-types';
 /**
  * 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
@@ -31,6 +31,17 @@ export declare const FileRules: {
     MaxSize: (bytes: number, message?: string) => FileValidationRule;
     Mime: (accept: string, message?: string) => FileValidationRule;
     VideoAspectRatio: (ratios: string[], message?: string, tolerancePercent?: number) => FileValidationRule;
+    /**
+     * Validates a video's width / height ratio against an inclusive `[min, max]` interval. Each
+     * bound is a `'w:h'` string or a decimal; both are optional, so the interval can be open-ended
+     * (`{ min }` = "this wide or wider", `{ max }` = "up to this"). `tolerancePercent` widens the
+     * interval outward on both edges. An empty `{}` specifies no constraint and accepts everything.
+     */
+    VideoAspectRatioRange: (range: {
+        min?: AspectRatioBound;
+        max?: AspectRatioBound;
+    }, message?: string, tolerancePercent?: number) => FileValidationRule;
+    VideoOrientation: (orientation: VideoOrientationValue, message?: string, tolerancePercent?: number) => FileValidationRule;
     VideoDimensions: (max: {
         width: number;
         height: number;

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

@@ -43,10 +43,25 @@ const readVideoDimensions = (file) => new Promise((resolve, reject) => {
     };
     video.src = url;
 });
-const parseRatio = (ratio) => {
-    const [w, h] = ratio.split(':').map((part) => parseFloat(part));
-    return h ? w / h : NaN;
+const parseRatio = (value) => {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) && value > 0 ? value : NaN;
+    }
+    if (value.includes(':')) {
+        const [w, h] = value.split(':').map((part) => parseFloat(part));
+        return h ? w / h : NaN;
+    }
+    const num = parseFloat(value);
+    return num > 0 ? num : NaN;
+};
+const resolveBound = (value) => {
+    if (value === undefined) {
+        return null;
+    }
+    const ratio = parseRatio(value);
+    return Number.isFinite(ratio) ? ratio : null;
 };
+const formatBound = (value) => (value === undefined ? '' : typeof value === 'number' ? String(value) : value);
 const formatExtensions = (extensions) => extensions.map((ext) => '.' + ext.replace(/^\./, '')).join(', ');
 const messages = new FileValidationLocalization();
 /**
@@ -113,6 +128,35 @@ export const FileRules = {
         });
         return matches ? null : (message ?? messages.aspectRatio(ratios.join(', ')));
     },
+    /**
+     * Validates a video's width / height ratio against an inclusive `[min, max]` interval. Each
+     * bound is a `'w:h'` string or a decimal; both are optional, so the interval can be open-ended
+     * (`{ min }` = "this wide or wider", `{ max }` = "up to this"). `tolerancePercent` widens the
+     * interval outward on both edges. An empty `{}` specifies no constraint and accepts everything.
+     */
+    VideoAspectRatioRange: (range, message, tolerancePercent = 1) => async (file) => {
+        const { width, height } = await readVideoDimensions(file);
+        if (!width || !height) {
+            return message ?? messages.aspectRatioRange(formatBound(range.min), formatBound(range.max));
+        }
+        const actual = width / height;
+        const lo = resolveBound(range.min);
+        const hi = resolveBound(range.max);
+        const factor = 1 + tolerancePercent / 100;
+        const okLo = lo === null || actual >= lo / factor;
+        const okHi = hi === null || actual <= hi * factor;
+        return okLo && okHi ? null : (message ?? messages.aspectRatioRange(formatBound(range.min), formatBound(range.max)));
+    },
+    VideoOrientation: (orientation, message, tolerancePercent = 1) => async (file) => {
+        const { width, height } = await readVideoDimensions(file);
+        if (!width || !height) {
+            return message ?? messages.orientation(orientation);
+        }
+        const actual = width / height;
+        const margin = tolerancePercent / 100;
+        const ok = orientation === 'landscape' ? actual > 1 + margin : orientation === 'portrait' ? actual < 1 - margin : Math.abs(actual - 1) <= margin;
+        return ok ? null : (message ?? messages.orientation(orientation));
+    },
     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;

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

@@ -23,3 +23,7 @@ export type FileValidationResult = {
     isValid: boolean;
     errors: string[];
 };
+/** Aspect-ratio bound: a `'w:h'` string (`'16:9'`) or a plain decimal (`1.78`). */
+export type AspectRatioBound = string | number;
+/** Video orientation class, derived from the width / height ratio. */
+export type VideoOrientationValue = 'landscape' | 'portrait' | 'square';

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

@@ -1,5 +1,5 @@
 export type { BlobWithName, FileWithBlobUrl, FileWithUploadUrl } from './types';
-export type { FileValidationResult, FileValidationRule, FileValidationRuleSets } from './file-validation-types';
+export type { AspectRatioBound, FileValidationResult, FileValidationRule, FileValidationRuleSets, VideoOrientationValue } 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';

package/dist/ui/grid-card/cmp.grid-card-media.svelte

@@ -146,8 +146,8 @@ playable (preserves card height). Optional `duration` overlay renders bottom-rig
 }
 .grid-card-media__duration-anchor {
   position: absolute;
-  bottom: 0.5rem;
-  right: 0.5rem;
+  bottom: 0.375rem;
+  right: 0.375rem;
   z-index: 1;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/kit",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "author": "StreamsCloud",
   "repository": {
     "type": "git",