@omnia/fx 8.0.110-vnext → 8.0.111-vnext

package/internal-do-not-import-from-here/ux/mediapickerV2/mediaproviderbase/GridViewMediaProviderComponent.d.ts

@@ -0,0 +1,64 @@
+import { IWebComponentInstance } from "../../../";
+import { MediaItem, ImageItem, VideoItem, ImageInformation, MediaPickerEnums, VideoInformation, MediaPickerImageTransformationResult, MediaPickerVideo } from "../../../models";
+import { MediaProviderComponentBase } from "./MediaProviderComponentBase";
+import "./GridViewMediaProviderComponent.css";
+export interface GridViewMediaProviderComponentProps {
+}
+export interface GridViewMediaProviderComponentSlots<MediaItemType extends MediaItem> {
+    mediaSelectionTop?: () => JSX.Element;
+    mediaSelectionBottom?: () => JSX.Element;
+    mediaGridItemHover?: (item: MediaItemType) => JSX.Element;
+    mediaGridItemOverlay?: (item: MediaItemType) => JSX.Element;
+    customSlot?: () => JSX.Element;
+}
+export declare abstract class GridViewMediaProviderComponent extends MediaProviderComponentBase implements IWebComponentInstance, GridViewMediaProviderComponentProps {
+    /**
+     * Get media items by search keyword
+     * @param searchKeyword
+     */
+    abstract getMediaItems(searchKeyword: string): Promise<Array<ImageItem | VideoItem>>;
+    /**
+     * Get more media items when reached the last item in grid while scrolling
+     * @param lastLoadedIndex
+     */
+    abstract getMoreMediaItems(lastLoadedIndex: number): Promise<Array<ImageItem | VideoItem>>;
+    /**
+     * Return the information for selected media item in grid
+     * @param mediaItem
+     */
+    abstract getMediaInfo(mediaItem: ImageItem | VideoItem): Promise<ImageInformation | VideoInformation>;
+    /**
+     * Manipulate the image result if needed before it is saved. Initiate the video result after video item is selected.
+     * @param resultToBeSaved
+     */
+    abstract beforeSaved(resultToBeSaved: MediaPickerImageTransformationResult | VideoInformation): Promise<MediaPickerImageTransformationResult | MediaPickerVideo>;
+    protected gridViewSlots: GridViewMediaProviderComponentSlots<MediaItem>;
+    private allResults;
+    private mediaGridItems;
+    protected displayPageSize: number;
+    protected enableLoadMoreButton: boolean;
+    protected searchStatus: MediaPickerEnums.MediaSearchStatus;
+    private isShowRetryGetSelectedImageInfoDialog;
+    private gridComponentKey;
+    private imageItemToRetryDownload;
+    private isRetryingGetSelectedImageInfo;
+    private isUpdatingInfiniteScroll;
+    private noMoreResult;
+    private gridViewStyles;
+    constructor();
+    protected selectGridItem(mediaItem: ImageItem | VideoItem): void;
+    protected setAllItems(mediaItems: Array<ImageItem | VideoItem>): void;
+    protected setEmptyResultHandler(): void;
+    protected setSearchStatus(status: MediaPickerEnums.MediaSearchStatus): void;
+    private retryToGetSelectedImageInfo;
+    private handleSelectedMediaItem;
+    private getMediaItemChunks;
+    private onGridViewSearch;
+    private appendGridItems;
+    private onGridViewScroll;
+    private renderRetryGetImageInfoDialog;
+    private renderGridViewItemSelection;
+    private closeRetryGetImageInfoDialog;
+    protected renderLoadMoreButton(): JSX.Element;
+    protected renderGridViewProvider(): JSX.Element;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/mediaproviderbase/MediaProviderComponentBase.css.d.ts

@@ -0,0 +1,9 @@
+export declare const MediaProviderComponentBaseStyles: {
+    baseWrapper: string;
+    providerWrapper: string;
+    loadingProviderWrapper: string;
+    providerContent: string;
+    loadingOverlayWrapper: (darkBackground: boolean) => string;
+    loadingWrapper: string;
+    gridWrapper: string;
+};

package/internal-do-not-import-from-here/ux/mediapickerV2/mediaproviderbase/MediaProviderComponentBase.d.ts

@@ -0,0 +1,73 @@
+import { IWebComponentInstance, OmniaContext } from "../../../";
+import { MediaPickerImageSettings, MediaPickerEnums, ImageInformation, MediaPickerVideo, MediaPickerStorageProviderContext, GuidValue, MediaPickerMedia, MediaPickerImageTransformationResult, Future } from "../../../models";
+import { OmniaUxLocalization } from "../../UxModels";
+import { MediaPickerProviderComponentProps } from "../../mediapicker";
+import { VueComponentBase } from "../../VueComponentBase";
+import { SettingsService, WebImageService, MediaPickerService } from "../../../services";
+import { MediaProviderBaseLocalization } from "./loc/localize";
+import { MediaPickerStore, MultilingualStore, useMediaPickerProviderStore } from "@omnia/fx/stores";
+import { useColorSchemaStore } from "../../theming-v2";
+export interface MediaProviderComponentBaseSlots {
+    bottom?: () => JSX.Element | Array<JSX.Element>;
+}
+export declare abstract class MediaProviderComponentBase extends VueComponentBase implements IWebComponentInstance, MediaPickerProviderComponentProps {
+    providerContext: MediaPickerStorageProviderContext;
+    providerId: GuidValue;
+    saved: (result: MediaPickerMedia) => void;
+    closed?: () => void;
+    imageSettings?: MediaPickerImageSettings;
+    preSelectedMedia?: MediaPickerVideo;
+    selectableMediaTypes?: Array<MediaPickerEnums.OmniaMediaTypes>;
+    setSearchKeyword: (value: string) => void;
+    uxLoc: OmniaUxLocalization;
+    mediaProviderBaseLoc: MediaProviderBaseLocalization.locInterface;
+    colors: ReturnType<typeof useColorSchemaStore>;
+    providerStore: ReturnType<typeof useMediaPickerProviderStore>;
+    /** Define method to get data based on search keyword. Null is to hide the search box in media picker. */
+    onSearch: (searchKeyword: string) => Promise<void>;
+    protected providerSlots: MediaProviderComponentBaseSlots;
+    protected onScroll: (payLoad: UIEvent) => void;
+    protected settingsService: SettingsService<any>;
+    protected webImageService: WebImageService;
+    protected omniaContext: OmniaContext;
+    protected mediaPickerService: MediaPickerService;
+    protected mediaPickerStore: MediaPickerStore;
+    protected multilingualStore: MultilingualStore;
+    private limitedSizeScalingSettings;
+    private imageTransformComponentInput;
+    private imageProviderResult;
+    private keepOriginalSizeOptionValue;
+    private selectedScalingOption;
+    private selectedImageScaling;
+    private isRetryingScalingImage;
+    private isShowRetryImageScalingDialog;
+    private isFileTypeIsNotSupportedDialog;
+    private isShowImageScalingDialog;
+    private selectedImageResolvablePromise;
+    private isSaved;
+    private selectedMediaInformation;
+    constructor();
+    protected save(resultToBeSaved: MediaPickerImageTransformationResult | MediaPickerVideo): void;
+    protected transformImage(imageInfo: ImageInformation): Future<MediaPickerImageTransformationResult>;
+    protected toggleLoadingUI(show: boolean, loadingStyle?: MediaPickerEnums.LoadingStyle): void;
+    private setImageTransformInput;
+    private getImageScalingSettingsKey;
+    private onImageTransformResultChanged;
+    private ensureRemoveBase64Format;
+    private addNewImage;
+    private initLimitedSizeScalingSettings;
+    private checkIfFileSizeExceededLimitation;
+    private handleValidatedImage;
+    private handleImageScaling;
+    private retryToScaleImage;
+    private processLimitedImageFileSize;
+    private onImageScalingOptionSelected;
+    private handleSelectedScalingOptionFromDialog;
+    private resizeImage;
+    private closeImageScalingDialog;
+    private resolveSavingImagePromise;
+    private closeRetryImageScalingDialog;
+    private closeFileTypeIsNotSupportedDialog;
+    private renderRetryImageScalingDialog;
+    protected renderBase(getProviderSlotsFunc: () => Array<JSX.Element> | JSX.Element): JSX.Element;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/mediaproviderbase/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MediaProviderComponentBase";
+export * from "./GridViewMediaProviderComponent";

package/internal-do-not-import-from-here/ux/mediapickerV2/mediaproviderbase/loc/localize.d.ts

@@ -0,0 +1,23 @@
+export declare module MediaProviderBaseLocalization {
+    const namespace = "Omnia.Ux.MediaProviderBase";
+    interface locInterface {
+        FileSizeWarningDialog: {
+            WarningBigSizeTitle: string;
+            WarningBigSizeMessage: string;
+            SmallOption: string;
+            MediumOption: string;
+            LargeOption: string;
+            KeepOriginalSizeOption: string;
+            KeepRatio: string;
+            RetryScalingImageMessage: string;
+        };
+        RetryDownloadDialog: {
+            RetryDownloadTitle: string;
+            RetryDownloadMessage: string;
+            RetryButton: string;
+        };
+        FileTypeIsNotSupportedDialog: {
+            FileTypeIsNotSupportedMessage: string;
+        };
+    }
+}

package/internal-do-not-import-from-here/ux/mediapickerproviders/pexelsprovider-V2/PexelProvider.css.d.ts

@@ -0,0 +1,5 @@
+export declare const PexelProviderStyles: {
+    wrapper: string;
+    text: string;
+    notify: string;
+};