@salla.sa/twilight-components 2.14.540 → 2.14.541

package/dist/types/components/salla-comments/salla-comment-item.d.ts

@@ -4,7 +4,6 @@ export declare class SallaCommentItem {
     componentDidLoad(): void;
     host: HTMLElement;
     private likeBtn;
-    private modal;
     /**
      * Single Comment Instance
     */
@@ -20,12 +19,15 @@ export declare class SallaCommentItem {
     has_order_trans: any;
     allowLikes: any;
     allowAttachImages: any;
+    allowAttachVideos: any;
     helpfulLabel: any;
     reviewDetailsLabel: any;
     likesCount: number;
     likedComments: any[];
     showReviewFactors: boolean;
     private getReplies;
+    private getImages;
+    private getVideos;
     private getDate;
     private getTime;
     private toggleLike;

package/dist/types/components/salla-file-upload/salla-file-upload.d.ts

@@ -1,6 +1,12 @@
 import { type EventEmitter } from '../../stencil-public-runtime';
 import type { FilePondFile } from './interfaces';
 import type { FilePond as FilePondType, FilePondErrorDescription } from 'filepond/types/index';
+interface PreviewFile {
+    id: string;
+    url: string;
+    mimeType?: string;
+    processing?: boolean;
+}
 export declare class SallaFileUpload {
     private filePondLoaded;
     private FilePond;
@@ -15,10 +21,30 @@ export declare class SallaFileUpload {
     filepond: FilePondType;
     host: HTMLElement;
     max_images_count: (count: number) => string;
+    max_videos_count: (count: number) => string;
     max_count_hint: (count: number) => string;
+    video_too_large: (size: string) => string;
+    video_too_long: (duration: string) => string;
     uploadedFiles: any[];
     isListScrollerListenerAdded: boolean;
     showMaxCountHint: boolean;
+    previewFiles: PreviewFile[];
+    private attachmentView;
+    private maxFilesNotified;
+    private validationRejectedFileIds;
+    private previewFilesSyncRaf;
+    /**
+     * Transient reservations for files currently passing add-validation, keyed by
+     * FilePond file id. FilePond runs beforeAddFile async and only inserts a file
+     * into `getFiles()` after validation resolves, so a batch of parallel picks
+     * would race if we counted the pond alone. We reserve a slot here synchronously
+     * for the in-flight window and always release it in `onaddfile` (once the file
+     * is committed to the pond and counted from there). Because committed files are
+     * always counted from `getFiles()` — never from this map — it cannot drift and
+     * "stick" the uploader at its limit across delete/re-upload cycles.
+     */
+    private inFlightFiles;
+    private previewObjectUrls;
     /**
      * The uploaded image link or URL
      */
@@ -103,6 +129,10 @@ export declare class SallaFileUpload {
      * Enable or disable adding multiple files
      */
     allowMultiple: boolean;
+    /**
+     * Enable the custom gallery preview instead of FilePond thumbnails.
+     */
+    enableGallery: boolean;
     /**
      * Allow drop to replace a file, only works when allowMultiple is false
      */
@@ -130,7 +160,8 @@ export declare class SallaFileUpload {
      */
     allowImagePreview: boolean;
     /**
-     * Fixed image preview height, overrides min and max preview height
+     * Fixed image preview height, overrides min and max preview height.
+     * Also sets the gallery thumbnail size when using the swiper preview (default: 75px).
      */
     imagePreviewHeight: number;
     /**
@@ -155,6 +186,24 @@ export declare class SallaFileUpload {
      * The maxmimum number of files that can be uploaded in parallel
      */
     maxParallelUploads: number;
+    /**
+     * Primary: maximum number of image files (split count mode).
+     * When set with or without maxVideosCount, maxFilesCount is ignored for count limits.
+     */
+    maxImagesCount: number;
+    /**
+     * Primary: maximum number of video files (split count mode).
+     * When set with or without maxImagesCount, maxFilesCount is ignored for count limits.
+     */
+    maxVideosCount: number;
+    /**
+     * Maximum size for video files only, e.g. 50MB or 750KB
+     */
+    maxVideoFileSize: `${number}MB` | `${number}KB`;
+    /**
+     * Maximum video duration in seconds
+     */
+    maxVideoDuration: number;
     /**
      * Set to true to enable custom validity messages.
      * FilePond will throw an error when a parent form is submitted and it contains invalid files.
@@ -259,14 +308,27 @@ export declare class SallaFileUpload {
     uploaded: EventEmitter<string>;
     uploadedHandler(): CustomEvent<string>;
     /**
-     * Event emitted when the file is about to be removed. Returns boolean value.
+     * Event emitted when the file is about to be removed. Returns the removed file id when available.
      */
-    removed: EventEmitter<FilePondFile>;
-    removedHandler(deletedFile: FilePondFile): CustomEvent<FilePondFile>;
+    removed: EventEmitter<string | number>;
+    /**
+     * Event emitted when the gallery preview list changes (upload/remove).
+     */
+    galleryUpdated: EventEmitter<{
+        count: number;
+        imageCount?: number;
+        videoCount?: number;
+        uploading?: boolean;
+    }>;
+    private emitRemovedFile;
+    removedHandler(deletedFile: FilePondFile, options?: {
+        skipEmit?: boolean;
+    }): void;
     /**
      *  Method to set option for filepond
      * */
     setOption(key: string, value: string | number): Promise<void>;
+    private generateUploadFileId;
     private getLabel;
     /**
      *
@@ -275,8 +337,69 @@ export declare class SallaFileUpload {
     private getFileSize;
     private getFormDataFileInput;
     private openFileBrowser;
+    private usesGalleryPreview;
+    private isValidPreviewUrl;
+    private getHiddenInputValue;
+    private usesSplitCountLimits;
+    private hasImageLimit;
+    private hasVideoLimit;
+    private getMaxImagesCount;
+    private getMaxVideosCount;
+    private getTotalMaxFiles;
+    private getImageMaxFileSizeString;
+    private getImageMaxFileSizeBytes;
+    private getVideoMaxFileSizeBytes;
+    private getFilePondMaxFileSizeValue;
+    private getFileMimeType;
+    private getFileUrlOrName;
+    private isVideoFile;
+    private getPondItemNameOrUrl;
+    private isVideoFileFromPond;
+    private isImageFileFromPond;
+    private getFileTypeCategory;
+    /**
+     * Effective count for a type = files committed to the pond + still-in-flight
+     * reservations that are not yet in the pond. Committed files come straight from
+     * `getFiles()` (the source of truth), so this self-heals after deletes and can
+     * never leave the uploader stuck at its limit.
+     */
+    private countAcceptedByType;
+    /** Effective total across all types (committed pond files + in-flight reservations). */
+    private countAcceptedTotal;
+    private reserveAcceptedFile;
+    private releaseAcceptedFile;
+    private getVideoDuration;
+    private notifyMaxImagesLimit;
+    private notifyMaxVideosLimit;
+    private notifyMaxFilesLimit;
+    private markValidationRejected;
+    private getUploadErrorMessageForFile;
+    private notifyUploadError;
+    private removeFailedFile;
+    private validateBeforeAddFile;
+    private renderGalleryThumb;
+    private releasePreviewObjectUrl;
+    private prunePreviewObjectUrls;
+    private revokeAllPreviewObjectUrls;
+    private getFilePreviewUrl;
+    private isFileUploading;
+    private getPreviewGalleryItems;
+    private getCountableGalleryItems;
+    private schedulePreviewFilesSync;
+    private mapItemsToPreviewFiles;
+    private emitGalleryCounts;
+    private syncPreviewFiles;
+    private enforceDropLabelVisibility;
+    private scheduleDropLabelVisibilityEnforcement;
+    private removePreviewFile;
+    private openPreview;
+    private getGalleryThumbSize;
+    private getGalleryStyles;
+    private renderPreviewGallery;
     private getFiles;
     componentWillLoad(): Promise<void>;
+    disconnectedCallback(): void;
     render(): any;
     componentDidLoad(): Promise<void>;
 }
+export {};

package/dist/types/components/salla-file-upload/upload-limits.d.ts

@@ -0,0 +1,49 @@
+export declare const IMAGE_UPLOAD_ACCEPT = "image/png, image/jpeg, image/jpg";
+/** Valid MIME types + extensions for native file pickers (macOS Finder requires real MIME types). */
+export declare const VIDEO_UPLOAD_ACCEPT = "video/mp4, video/quicktime, video/x-msvideo, video/x-matroska, video/webm, .mp4, .mov, .avi, .mkv, .webm";
+export declare const MEDIA_UPLOAD_ACCEPT = "image/png, image/jpeg, image/jpg, video/mp4, video/quicktime, video/x-msvideo, video/x-matroska, video/webm, .mp4, .mov, .avi, .mkv, .webm";
+export declare function buildMediaUploadAccept(allowImages: boolean, allowVideos: boolean): string;
+export declare function usesSplitCountLimits(maxImagesCount?: number, maxVideosCount?: number): boolean;
+export declare function isConfiguredLimit(limit?: number): boolean;
+export declare function getMaxImagesCount(maxImagesCount?: number): number;
+export declare function getMaxVideosCount(maxVideosCount?: number): number;
+export declare function getTotalMaxFiles(maxFilesCount: number, maxImagesCount?: number, maxVideosCount?: number): number;
+export declare function isVideoMimeType(mimeType?: string, urlOrName?: string): boolean;
+export declare function isImageMimeType(mimeType?: string, urlOrName?: string): boolean;
+export declare function parseSizeToBytes(size: string): number;
+export declare function formatBytesAsSize(bytes: number): string;
+export declare function formatDuration(seconds: number): string;
+export declare function getFilePondMaxFileSize(maxFileSize: string | undefined, storeUploadSizeKb: number | undefined, maxVideoFileSize: string | undefined): string | null;
+export interface UploadErrorMessageOptions {
+    isVideo?: boolean;
+    maxVideoFileSizeLabel?: string;
+    maxVideoBytes?: number | null;
+    tooLargeLabel: string;
+    invalidTypeLabel: string;
+    genericErrorLabel: string;
+    videoTooLarge: (size: string) => string;
+}
+export declare function isUploadSizeError(error: {
+    type?: string;
+    body?: string;
+}): boolean;
+export declare function isUploadTypeError(error: {
+    type?: string;
+    body?: string;
+}): boolean;
+export declare function getUploadErrorMessage(error: {
+    type?: string;
+    body?: string;
+}, options: UploadErrorMessageOptions): string;
+/** FilePond FileStatus values used for gallery counting. */
+export declare const FILE_STATUS_INIT = 1;
+export declare const FILE_STATUS_IDLE = 2;
+export declare const FILE_STATUS_PROCESSING = 3;
+export declare const FILE_STATUS_PROCESSING_COMPLETE = 5;
+export declare const FILE_STATUS_PROCESSING_ERROR = 6;
+export declare const FILE_STATUS_LOADING = 7;
+export declare const FILE_STATUS_LOAD_ERROR = 8;
+export declare const FILE_STATUS_PROCESSING_QUEUED = 9;
+export declare function shouldCountGalleryFile(status: number): boolean;
+/** Exclude in-flight add validation so limit counters don't spike on rejected picks. */
+export declare function shouldCountGalleryLimit(status: number): boolean;

package/dist/types/components/salla-rating-modal/rating-modal-media.d.ts

@@ -0,0 +1,38 @@
+export declare const MAX_IMAGE_UPLOAD_LIMIT = 10;
+export declare const MAX_VIDEO_UPLOAD_LIMIT = 5;
+export declare const MAX_VIDEO_FILE_SIZE: `${number}MB`;
+export declare const MAX_VIDEO_DURATION = 60;
+export declare const MAX_PARALLEL_UPLOADS = 10;
+export declare function isVideoUrl(url: string): boolean;
+export declare function splitMediaUrls(urls: string[]): {
+    images: string[];
+    videos: string[];
+};
+export declare function getMediaUrlsByType(items: Array<{
+    url?: string;
+}>): {
+    images: string[];
+    videos: string[];
+};
+export declare function parseMediaField(value: string | string[]): string[];
+export declare function countMediaByType(items: Array<{
+    url?: string;
+}>): {
+    image: number;
+    video: number;
+};
+export declare function createPreloadedMediaItem(url: string): {
+    id: string;
+    url: string;
+};
+export declare function removeUploadedImage(images: Array<{
+    id?: string | number;
+    url?: string;
+}>, removedId: string | number): {
+    id?: string | number;
+    url?: string;
+}[];
+export declare function syncHiddenMediaInputs(imagesInput: HTMLInputElement | undefined, videosInput: HTMLInputElement | undefined, items: Array<{
+    url?: string;
+}>): void;
+export declare function normalizeSubmittedMedia(data: Record<string, unknown>, allowAttachImages: boolean, allowAttachVideos: boolean): void;

package/dist/types/components/salla-rating-modal/salla-rating-modal-v2.d.ts

@@ -19,12 +19,17 @@ export declare class SallaRatingModalV2 {
     defaultMode: boolean;
     deleteMode: boolean;
     shouldOpenDeleteModal: boolean;
-    editType: 'product' | 'store' | 'shipping';
-    editFeedbackId: number;
-    deleteFeedbackId: number;
+    editType?: 'product' | 'store' | 'shipping';
+    editFeedbackId?: number;
+    deleteFeedbackId?: number;
     editItem: any;
     allowAttachImages: boolean;
+    allowAttachVideos: boolean;
     allowContactSupport: boolean;
+    uploadCounts: Record<number, number>;
+    uploadImageCounts: Record<number, number>;
+    uploadVideoCounts: Record<number, number>;
+    hasUploadsInProgress: boolean;
     loyaltyImageRatingPoints: number;
     private dragAndDropFilesLabel;
     private contactSubjectLabel;
@@ -43,6 +48,9 @@ export declare class SallaRatingModalV2 {
     private loyaltyPointsForImagesLabel;
     private contentRefs;
     private hiddenInputs;
+    private hiddenVideoInputs;
+    private editHiddenVideosInput?;
+    private uploadingByProductId;
     private userFilledFactorKeys;
     private boundRatingRows;
     private stepsCount;
@@ -59,17 +67,30 @@ export declare class SallaRatingModalV2 {
     private steps;
     private dots;
     private submitted;
-    private MAX_UPLOAD_LIMIT;
     private thanksCountdownInterval;
+    private MAX_IMAGE_UPLOAD_LIMIT;
+    private MAX_VIDEO_UPLOAD_LIMIT;
+    private MAX_VIDEO_FILE_SIZE;
+    private MAX_VIDEO_DURATION;
+    private MAX_PARALLEL_UPLOADS;
     /**
      * The order id, to rate on its products & shipping
      */
-    orderId: number;
-    host: HTMLElement;
+    orderId?: number;
+    host: HTMLElement | undefined;
     /**
      * Show the rating modal
      */
     private syncStoreSettings;
+    private canAttachMedia;
+    private getMediaUploadAccept;
+    private refreshMediaLabels;
+    private getAllowedMediaTypesLabel;
+    private getMaxUploadHintLabel;
+    private setUploadCount;
+    private setUploaderProcessing;
+    private scheduleUploaderHeightRefresh;
+    private handleGalleryCountUpdate;
     /** Encrypted order id from page config / prop — used to fetch order details. */
     private getRatingOrderId;
     /** Numeric order id from API response — used when submitting ratings. */
@@ -95,7 +116,9 @@ export declare class SallaRatingModalV2 {
     }): Promise<void>;
     fetchEditItem(feedbackId: number): Promise<void>;
     private editReview;
-    openDeleteModal(params: any): Promise<unknown>;
+    openDeleteModal(params: {
+        feedback_id: number;
+    }): Promise<unknown>;
     deleteReview(): Promise<void>;
     /**
      * Show the rating modal

package/dist/types/components/salla-review-factors-tags/helpers.d.ts

@@ -12,5 +12,5 @@ export declare function resolveReviewFactors(order: {
         products?: unknown;
     };
 } | null | undefined, ratingId?: number, productId?: number, itemId?: number): ReviewFactor[];
-export declare function fetchOrder(orderId: number): Promise<unknown>;
+export declare function fetchOrder(orderId: string | number): Promise<unknown>;
 export declare function resetOrderCacheForTests(): void;

package/dist/types/components/salla-review-factors-tags/interfaces.d.ts

@@ -11,6 +11,13 @@ export interface ProductRating {
     product?: {
         id?: number;
     };
+    stars?: number;
+    rating?: number;
+    content?: string;
+    is_pending?: boolean;
+    can_update?: boolean;
+    images?: string[];
+    videos?: string[];
     factor_reviews?: ReviewFactor[];
     review_factors?: ReviewFactor[];
     factors?: ReviewFactor[];

package/dist/types/components/salla-review-order-item/interfaces.d.ts

@@ -0,0 +1,30 @@
+import type { ProductRating } from '../salla-review-factors-tags/interfaces';
+export interface AttachmentMediaSource {
+    images?: string[];
+    videos?: string[];
+    product?: {
+        id?: number | string;
+    };
+}
+export interface OrderItemRating extends AttachmentMediaSource {
+    id?: number | string;
+    stars?: number;
+    content?: string;
+    is_pending?: boolean;
+    can_update?: boolean;
+}
+export type ProductRatingMediaSource = ProductRating & AttachmentMediaSource;
+export interface OrderItem {
+    id?: number | string;
+    product?: {
+        id?: number | string;
+    };
+    rating?: OrderItemRating | null;
+}
+export interface OrderResponse {
+    items?: OrderItem[];
+    rating?: {
+        product?: unknown;
+        products?: unknown;
+    };
+}

package/dist/types/components/salla-review-order-item/salla-review-order-item.d.ts

@@ -0,0 +1,30 @@
+import type { OrderItem, ProductRatingMediaSource } from './interfaces';
+export declare class SallaReviewOrderItem {
+    /**
+     * Product id used to match `items[].product.id` and `rating.product[].product.id`.
+     * The order itself is fetched via `page.id`.
+     */
+    productId?: string | number;
+    orderItem?: OrderItem;
+    fetchOrderId?: string | number;
+    productRatings: ProductRatingMediaSource[];
+    allowUpdate: boolean;
+    componentWillLoad(): Promise<void>;
+    onProductIdChange(): Promise<void>;
+    /** Real order id used for `GET /orders/{id}`. */
+    private resolveFetchOrderId;
+    private sameId;
+    private label;
+    private toOrderItemRating;
+    /**
+     * Build the reviewed line item from:
+     * - `order.items[]` matched by `items[].product.id`
+     * - `order.rating.product[]` matched by `rating.product[].product.id`
+     */
+    private resolveOrderItem;
+    private loadOrderItem;
+    private renderActions;
+    private serializeRatingMedia;
+    private serializeProductRatings;
+    render(): any;
+}