@omnia/fx 8.0.120-dev → 8.0.122-dev

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutBlockRenderer.d.ts

@@ -1,6 +1,9 @@
 import { Block, LayoutEngineRenderContext, SectionSettings } from "@omnia/fx-models";
 export declare const LayoutBlockRenderer: {
     new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        colorSchemaType?: any;
+        container?: any;
+        colors?: any;
         "render-context": {
             type: import("vue").PropType<LayoutEngineRenderContext<Block, SectionSettings>>;
         };
@@ -16,6 +19,9 @@ export declare const LayoutBlockRenderer: {
         blockInstanceCreated: (blockInstance: any) => any;
         blockInstanceCacheKeyUpdated: (blockInstance: any) => any;
     }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        colorSchemaType?: any;
+        container?: any;
+        colors?: any;
         "render-context": {
             type: import("vue").PropType<LayoutEngineRenderContext<Block, SectionSettings>>;
         };
@@ -26,7 +32,11 @@ export declare const LayoutBlockRenderer: {
         onBlockInstanceCreated?: (blockInstance: any) => any;
         onGetBlock?: (ref: any) => any;
         onBlockInstanceCacheKeyUpdated?: (blockInstance: any) => any;
-    }, {}, true, {}, {}, {
+    }, {
+        container?: any;
+        colorSchemaType?: any;
+        colors?: any;
+    }, true, {}, {}, {
         P: {};
         B: {};
         D: {};
@@ -34,6 +44,9 @@ export declare const LayoutBlockRenderer: {
         M: {};
         Defaults: {};
     }, Readonly<import("vue").ExtractPropTypes<{
+        colorSchemaType?: any;
+        container?: any;
+        colors?: any;
         "render-context": {
             type: import("vue").PropType<LayoutEngineRenderContext<Block, SectionSettings>>;
         };
@@ -44,11 +57,18 @@ export declare const LayoutBlockRenderer: {
         onBlockInstanceCreated?: (blockInstance: any) => any;
         onGetBlock?: (ref: any) => any;
         onBlockInstanceCacheKeyUpdated?: (blockInstance: any) => any;
-    }, () => JSX.Element, {}, {}, {}, {}>;
+    }, () => JSX.Element, {}, {}, {}, {
+        container?: any;
+        colorSchemaType?: any;
+        colors?: any;
+    }>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    colorSchemaType?: any;
+    container?: any;
+    colors?: any;
     "render-context": {
         type: import("vue").PropType<LayoutEngineRenderContext<Block, SectionSettings>>;
     };
@@ -63,8 +83,16 @@ export declare const LayoutBlockRenderer: {
     getBlock: (ref: any) => any;
     blockInstanceCreated: (blockInstance: any) => any;
     blockInstanceCacheKeyUpdated: (blockInstance: any) => any;
-}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{} & {
+}, string, {
+    container?: any;
+    colorSchemaType?: any;
+    colors?: any;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{
+        container?: any;
+        colorSchemaType?: any;
+        colors?: any;
+    } & {
         renderContext?: LayoutEngineRenderContext<Block, SectionSettings>;
         "render-context"?: LayoutEngineRenderContext<Block, SectionSettings>;
     }>, "onBlockInstanceCreated" | "onGetBlock" | "onBlockInstanceCacheKeyUpdated"> & {

package/internal-do-not-import-from-here/ux/layoutcanvas/shared/layoutitemsrenderer/LayoutSectionRenderer.d.ts

@@ -14,6 +14,9 @@ export declare const LayoutSectionRenderer: {
         renderContext: {
             type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
         };
+        colorSchemaType?: any;
+        container?: any;
+        colors?: any;
     }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
         "render-context": {
             type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
@@ -21,7 +24,14 @@ export declare const LayoutSectionRenderer: {
         renderContext: {
             type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
         };
-    }>>, {}, true, {}, {}, {
+        colorSchemaType?: any;
+        container?: any;
+        colors?: any;
+    }>>, {
+        container?: any;
+        colorSchemaType?: any;
+        colors?: any;
+    }, true, {}, {}, {
         P: {};
         B: {};
         D: {};
@@ -35,7 +45,14 @@ export declare const LayoutSectionRenderer: {
         renderContext: {
             type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
         };
-    }>>, () => JSX.Element, {}, {}, {}, {}>;
+        colorSchemaType?: any;
+        container?: any;
+        colors?: any;
+    }>>, () => JSX.Element, {}, {}, {}, {
+        container?: any;
+        colorSchemaType?: any;
+        colors?: any;
+    }>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
@@ -46,8 +63,19 @@ export declare const LayoutSectionRenderer: {
     renderContext: {
         type: import("vue").PropType<LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>>;
     };
-}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{} & {
+    colorSchemaType?: any;
+    container?: any;
+    colors?: any;
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    container?: any;
+    colorSchemaType?: any;
+    colors?: any;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{
+        container?: any;
+        colorSchemaType?: any;
+        colors?: any;
+    } & {
         renderContext?: LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>;
         "render-context"?: LayoutEngineRenderContext<Section<SectionSettings>, import("@omnia/fx-models").LayoutItemSettings>;
     }>, never>;

package/internal-do-not-import-from-here/ux/mediapickerV2/Utils/getMediaProvider.d.ts

@@ -0,0 +1,8 @@
+import { MediaPickerPersistedImage, MediaPickerProvider, MediaPickerVideo } from "@omnia/fx-models";
+/**
+ * At the time of writing this, the only provider that has editor is the video providers
+ * @param media the media
+ * @param registeredProviders the registered providers
+ * @returns return the provider that has editor for the media
+ */
+export declare function getMediaProviderEditor(media: MediaPickerVideo | MediaPickerPersistedImage, registeredProviders: MediaPickerProvider[]): MediaPickerProvider;

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

@@ -0,0 +1 @@
+export * from "./getMediaProvider";

package/internal-do-not-import-from-here/ux/mediapickerV2/chrome/MediaPicker.css.d.ts

@@ -5,4 +5,6 @@ export declare const MediaPickerStyles: {
         wrapper: string;
         positioner: string;
     };
+    loadingOverlayWrapper: (darkBackground: boolean) => string;
+    loadingProgressWrapper: string;
 };

package/internal-do-not-import-from-here/ux/mediapickerV2/chrome/MediaPicker.d.ts

@@ -1,7 +1,6 @@
-import { useThemeStoreV2 } from "@omnia/fx/ux";
 import { VNodeChild } from "vue";
-import { MediaPickerEnums, MediaPickerImageSettings, MediaPickerStorageProviderContext, MediaPickerMedia } from "@omnia/fx-models";
-export type RegisterThemeStore = (store: ReturnType<typeof useThemeStoreV2>) => void;
+import { MediaPickerEnums, MediaPickerImageSettings, MediaPickerProvider, MediaPickerStorageProviderContext, MediaPickerMedia } from "@omnia/fx-models";
+import { SelectedMedia } from "./types";
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
         "v-slots": import("vue").Prop<{
@@ -38,29 +37,35 @@ declare const _default: {
             type: import("vue").PropType<boolean>;
             required: false;
         };
+        "onUpdate:selectedMedia": {
+            type: import("vue").PropType<(value: SelectedMedia) => any>;
+        };
+        "v-model:selectedMedia": {
+            type: import("vue").PropType<SelectedMedia>;
+            required: false;
+        };
+        selectedMedia: {
+            type: import("vue").PropType<SelectedMedia>;
+            required: false;
+        };
         "provider-context": {
             type: import("vue").PropType<MediaPickerStorageProviderContext>;
         };
         providerContext: {
             type: import("vue").PropType<MediaPickerStorageProviderContext>;
         };
+        "provider-configuration": {
+            type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+        };
+        providerConfiguration: {
+            type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+        };
         "selectable-media-types": {
             type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
         };
         selectableMediaTypes: {
             type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
         };
-        "onUpdate:selectedMedia": {
-            type: import("vue").PropType<(value: MediaPickerMedia | MediaPickerMedia[]) => any>;
-        };
-        "v-model:selectedMedia": {
-            type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-            required: false;
-        };
-        selectedMedia: {
-            type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-            required: false;
-        };
         "onUpdate:modelValue": {
             type: import("vue").PropType<(value: boolean) => any>;
         };
@@ -172,29 +177,35 @@ declare const _default: {
             type: import("vue").PropType<boolean>;
             required: false;
         };
+        "onUpdate:selectedMedia": {
+            type: import("vue").PropType<(value: SelectedMedia) => any>;
+        };
+        "v-model:selectedMedia": {
+            type: import("vue").PropType<SelectedMedia>;
+            required: false;
+        };
+        selectedMedia: {
+            type: import("vue").PropType<SelectedMedia>;
+            required: false;
+        };
         "provider-context": {
             type: import("vue").PropType<MediaPickerStorageProviderContext>;
         };
         providerContext: {
             type: import("vue").PropType<MediaPickerStorageProviderContext>;
         };
+        "provider-configuration": {
+            type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+        };
+        providerConfiguration: {
+            type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+        };
         "selectable-media-types": {
             type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
         };
         selectableMediaTypes: {
             type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
         };
-        "onUpdate:selectedMedia": {
-            type: import("vue").PropType<(value: MediaPickerMedia | MediaPickerMedia[]) => any>;
-        };
-        "v-model:selectedMedia": {
-            type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-            required: false;
-        };
-        selectedMedia: {
-            type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-            required: false;
-        };
         "onUpdate:modelValue": {
             type: import("vue").PropType<(value: boolean) => any>;
         };
@@ -307,29 +318,35 @@ declare const _default: {
             type: import("vue").PropType<boolean>;
             required: false;
         };
+        "onUpdate:selectedMedia": {
+            type: import("vue").PropType<(value: SelectedMedia) => any>;
+        };
+        "v-model:selectedMedia": {
+            type: import("vue").PropType<SelectedMedia>;
+            required: false;
+        };
+        selectedMedia: {
+            type: import("vue").PropType<SelectedMedia>;
+            required: false;
+        };
         "provider-context": {
             type: import("vue").PropType<MediaPickerStorageProviderContext>;
         };
         providerContext: {
             type: import("vue").PropType<MediaPickerStorageProviderContext>;
         };
+        "provider-configuration": {
+            type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+        };
+        providerConfiguration: {
+            type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+        };
         "selectable-media-types": {
             type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
         };
         selectableMediaTypes: {
             type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
         };
-        "onUpdate:selectedMedia": {
-            type: import("vue").PropType<(value: MediaPickerMedia | MediaPickerMedia[]) => any>;
-        };
-        "v-model:selectedMedia": {
-            type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-            required: false;
-        };
-        selectedMedia: {
-            type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-            required: false;
-        };
         "onUpdate:modelValue": {
             type: import("vue").PropType<(value: boolean) => any>;
         };
@@ -439,29 +456,35 @@ declare const _default: {
         type: import("vue").PropType<boolean>;
         required: false;
     };
+    "onUpdate:selectedMedia": {
+        type: import("vue").PropType<(value: SelectedMedia) => any>;
+    };
+    "v-model:selectedMedia": {
+        type: import("vue").PropType<SelectedMedia>;
+        required: false;
+    };
+    selectedMedia: {
+        type: import("vue").PropType<SelectedMedia>;
+        required: false;
+    };
     "provider-context": {
         type: import("vue").PropType<MediaPickerStorageProviderContext>;
     };
     providerContext: {
         type: import("vue").PropType<MediaPickerStorageProviderContext>;
     };
+    "provider-configuration": {
+        type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+    };
+    providerConfiguration: {
+        type: import("vue").PropType<(providers: MediaPickerProvider[]) => MediaPickerProvider[]>;
+    };
     "selectable-media-types": {
         type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
     };
     selectableMediaTypes: {
         type: import("vue").PropType<MediaPickerEnums.OmniaMediaTypes[]>;
     };
-    "onUpdate:selectedMedia": {
-        type: import("vue").PropType<(value: MediaPickerMedia | MediaPickerMedia[]) => any>;
-    };
-    "v-model:selectedMedia": {
-        type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-        required: false;
-    };
-    selectedMedia: {
-        type: import("vue").PropType<MediaPickerMedia | MediaPickerMedia[]>;
-        required: false;
-    };
     "onUpdate:modelValue": {
         type: import("vue").PropType<(value: boolean) => any>;
     };
@@ -611,11 +634,13 @@ declare const _default: {
         } & {
             activator?: () => VNodeChild;
         };
-        selectedMedia?: MediaPickerMedia | MediaPickerMedia[];
-        "onUpdate:selectedMedia"?: (value: MediaPickerMedia | MediaPickerMedia[]) => any;
-        "v-model:selectedMedia"?: MediaPickerMedia | MediaPickerMedia[];
+        selectedMedia?: SelectedMedia;
+        "onUpdate:selectedMedia"?: (value: SelectedMedia) => any;
+        "v-model:selectedMedia"?: SelectedMedia;
         selectableMediaTypes?: MediaPickerEnums.OmniaMediaTypes[];
         "selectable-media-types"?: MediaPickerEnums.OmniaMediaTypes[];
+        providerConfiguration?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
+        "provider-configuration"?: (providers: MediaPickerProvider[]) => MediaPickerProvider[];
         "provider-context"?: MediaPickerStorageProviderContext;
         enableGallery?: boolean;
         "enable-gallery"?: boolean;

package/internal-do-not-import-from-here/ux/mediapickerV2/chrome/components/MediaGallerySelector.css.d.ts

@@ -2,4 +2,5 @@ export declare const MediaGallerySelectorStyles: {
     cardWrapper: string;
     cardWrapperSelected: (dark: boolean) => string;
     wrapper: string;
+    deleteButton: string;
 };

package/internal-do-not-import-from-here/ux/mediapickerV2/chrome/core/MediaFileProcessor.d.ts

@@ -1,4 +1,4 @@
-import { IMediaFileProcessor, ImageInformation, ImageItem, MediaPickerImageScalingDefinition, MediaPickerImageTransformationResult, VideoInformation, VideoItem } from "@omnia/fx-models";
+import { IMediaFileProcessor, ImageInformation, ImageItem, MediaPickerBase64Image, MediaPickerImageScalingDefinition, MediaPickerImageTransformationResult, VideoInformation, VideoItem } from "@omnia/fx-models";
 import { WebImageService } from "@omnia/fx/services";
 export declare class MediaFileProcessor implements IMediaFileProcessor {
     protected webImageService: WebImageService;
@@ -6,5 +6,5 @@ export declare class MediaFileProcessor implements IMediaFileProcessor {
     getMediaInfo(mediaItem: ImageItem | VideoItem): Promise<ImageInformation | VideoInformation>;
     onResizeImage(image: ImageInformation, scalingSettings: MediaPickerImageScalingDefinition): Promise<ImageInformation>;
     private ensureRemoveBase64Format;
-    onTransformImage(image: ImageInformation): MediaPickerImageTransformationResult;
+    onTransformImage(image: ImageInformation | MediaPickerBase64Image): MediaPickerImageTransformationResult;
 }

package/internal-do-not-import-from-here/ux/mediapickerV2/chrome/core/MediaPickerImageHandler.d.ts

@@ -1,3 +1,4 @@
+import { MediaPickerLimitedSizeSettings } from "@omnia/fx-models";
 export declare class MediaPickerImageHandler {
     /**
      * Converts a byte to an byte array
@@ -30,4 +31,5 @@ export declare class MediaPickerImageHandler {
     * @return {string} imgUrl
     */
     static retrieveImageDatafromSVG(svgImg: any): string;
+    static getDefaultLimitedSizeSettings(): MediaPickerLimitedSizeSettings;
 }

package/internal-do-not-import-from-here/ux/mediapickerV2/chrome/core/utils.d.ts

@@ -1,4 +1,4 @@
-export declare namespace Utils {
+export declare namespace MediaPickerUtils {
     const nameof: <T>(name: keyof T) => keyof T;
     function isImageTransformationResult(obj: any): boolean;
     function isVideoMediaPicker(obj: any): boolean;

package/internal-do-not-import-from-here/ux/mediapickerV2/chrome/types.d.ts

@@ -0,0 +1,2 @@
+import { MediaPickerMediaItem } from "../stores";
+export type SelectedMedia = MediaPickerMediaItem | Array<MediaPickerMediaItem>;

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/gallery/ImageHandler.d.ts

@@ -0,0 +1,12 @@
+import { IMediaPickerGalleryHandler } from "../../interfaces";
+import { MediaState } from "../../stores";
+export declare class ImageGalleryHandler implements IMediaPickerGalleryHandler {
+    private imageTransformerStore;
+    private galleryStore;
+    private providerStore;
+    /**
+     * @description the handler for when a media is selected, which handles the way the media is updated/transformed
+     */
+    onSelectMedia(_: number, media: MediaState): void;
+    private renderImageTransformerAlongsideGallerySelector;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/gallery/VideoHandler.d.ts

@@ -0,0 +1,9 @@
+import { IMediaPickerGalleryHandler } from "../../interfaces";
+import { MediaState } from "../../stores";
+export declare class VideoGalleryHandler implements IMediaPickerGalleryHandler {
+    private galleryStore;
+    private providerStore;
+    private imageTransformerStore;
+    onSelectMedia: (index: number, media: MediaState) => void;
+    private renderVideoProviderEditorAlongSideGallerySelector;
+}

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

@@ -0,0 +1,2 @@
+export * from "./ImageHandler";
+export * from "./VideoHandler";

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/imagetransformer/cropByRatio.d.ts

@@ -0,0 +1,24 @@
+import { MediaPickerCropTransformation, MediaPickerImageRatio, MediaPickerTransformation } from "@omnia/fx-models";
+import { IImageTransformHandler } from "../../interfaces";
+export interface MediaPickerCropByRatioTransformation extends MediaPickerTransformation {
+    ratio: MediaPickerImageRatio;
+    isDefaultImageCrop: boolean;
+}
+/**
+ * Image cropper by ratio handler, used when user select a ratio to crop the image
+ */
+export declare class ImageCropperByRatioHandler implements IImageTransformHandler {
+    private imageTransformationStore;
+    /**
+     * @description For the ratio it can come from either the default ratio (image ratio) OR the rollup ratio (rendition ratio)
+     * - default ratio, ensure the crop area => update the crop area in the transformer info
+     * - rendition ratio, ensure the crop area => update the crop area in the rendition data
+     * @param param0
+     */
+    transform({ ratio, isDefaultImageCrop }: MediaPickerCropByRatioTransformation): Promise<void>;
+    updateTransformationData(options: MediaPickerCropTransformation): Promise<void>;
+    private updateTransformImage;
+    private updateRendition;
+    private isCustomRatio;
+    private ensureCropZoneRect;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/imagetransformer/filter.d.ts

@@ -0,0 +1,11 @@
+import { IImageTransformHandler } from "../../interfaces";
+import { MediaPickerFilterTransformation } from "@omnia/fx-models";
+/**
+ * Image filter handler
+ */
+export declare class ImageFilterHandler implements IImageTransformHandler {
+    private imageTransformationStore;
+    private mediaPickerService;
+    transform(options: MediaPickerFilterTransformation): Promise<void>;
+    updateTransformationData(options: MediaPickerFilterTransformation): Promise<void>;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/imagetransformer/flip.d.ts

@@ -0,0 +1,8 @@
+import { IImageTransformHandler } from "../../interfaces";
+import { MediaPickerFlipTransformation } from "@omnia/fx-models";
+export declare class ImageFlipHandler implements IImageTransformHandler {
+    private imageTransformationStore;
+    private mediaPickerService;
+    transform(options: MediaPickerFlipTransformation): Promise<void>;
+    updateTransformationData(options: MediaPickerFlipTransformation): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+export * from "./cropByRatio";
+export * from "./filter";
+export * from "./flip";
+export * from "./utils";

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/imagetransformer/utils.d.ts

@@ -0,0 +1,13 @@
+import { MediaPickerService } from "@omnia/fx/services";
+import { ImageTransformerStore } from "../../imagetransformer/store";
+export type LoadSourceImageTransformationToCanvasParams = {
+    mediaPickerService: MediaPickerService;
+    imageTransformationStore: ImageTransformerStore;
+};
+export type UpdateImageTransformationResultParams = LoadSourceImageTransformationToCanvasParams;
+/**
+ * @param {UpdateImageTransformationResultParams} params the params needed to update the transformed image, including the media picker service and the image transformation store
+ * @description used after image updated by the image transform handler. It updates the transformed image in the store.
+ * @returns new image info ater the transformation
+ */
+export declare function updateTransformedImageBase64({ mediaPickerService, imageTransformationStore, }: UpdateImageTransformationResultParams): Promise<import("@omnia/fx-models").MediaPickerImageInformation>;

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

@@ -0,0 +1,3 @@
+export * from "./gallery";
+export * from "./provider";
+export * from "./imagetransformer";

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/provider/BaseImageHandler.d.ts

@@ -0,0 +1,47 @@
+import { ImageInformation, ImageItem } from "@omnia/fx-models";
+import { IMediaPickerImageProviderHandler, ProcessImageOptions } from "../../interfaces";
+import { IMediaFileProcessor } from "@omnia/fx-models";
+/**
+ * Base class for image in providers
+ */
+export declare class BaseProviderImageHandler implements IMediaPickerImageProviderHandler {
+    private providerStore;
+    private galleryStore;
+    private settingsService;
+    private mediaPickerStore;
+    private imageGalleryHandler;
+    private commonStore;
+    private imageTransformationStore;
+    fileProcessor: IMediaFileProcessor;
+    constructor();
+    /**
+     * @description handle select image event in the provider
+     * - download image to get its info
+     * - scale image if needed
+     * - add image to gallery
+     * @param media the image that gets selected in the provider
+     */
+    selectMedia(mediaItem: ImageItem): Promise<void>;
+    /**
+     * Each provider will implement its search method, if it supports search
+     * @description search images in the provider, if not implemented, it will return empty list
+     * @param _ search text
+     * @returns list of images that match the search text
+     */
+    search(_: string): Promise<any[]>;
+    /**
+     * Each provider will implement its search method, if it supports search
+     * @description search images in the provider, if not implemented, it will return empty list
+     * @param _ search text
+     * @returns list of images that match the search text
+     */
+    searchMore(_: string, __: number): Promise<any[]>;
+    private doesImageSupportTransformation;
+    selectImageInfo(imageInfo: ImageInformation): Promise<void>;
+    handleImageScaling(imageInfo: ImageInformation): Promise<boolean>;
+    private doesFileSizeExceedLimit;
+    private ensureLimitedScalingSettings;
+    processImageAndAddToGallery(options: ProcessImageOptions): Promise<void>;
+    private addImageToGallery;
+    private handleResizeImage;
+}

package/internal-do-not-import-from-here/ux/mediapickerV2/handlers/provider/BaseVideoHandler.d.ts

@@ -0,0 +1,36 @@
+import { GuidValue, MediaPickerVideo } from "@omnia/fx-models";
+import { IMediaPickerVideoProviderHandler } from "../../interfaces";
+import { IMediaFileProcessor } from "@omnia/fx-models";
+/**
+ * Base class for video providers
+ */
+export declare class BaseProviderVideoHandler implements IMediaPickerVideoProviderHandler {
+    private providerStore;
+    private galleryStore;
+    private videoGalleryHandler;
+    fileProcessor: IMediaFileProcessor;
+    constructor();
+    /**
+     * @description handle select media event in the provider, which initializes the media state and adds it to the gallery
+     * @param media the video that gets selected in the provider
+     */
+    selectMedia(media: MediaPickerVideo): Promise<void>;
+    /**
+     * @param media The media picker video that gets updated
+     * @param id media state id, which will get from the store
+     */
+    updateMedia(media: MediaPickerVideo, id: GuidValue): Promise<void>;
+    /**
+     * @description handle the search event in the provider
+     * @param searchKeyword search keyword
+     * @returns {Promise<Array<MediaItem>>} the result of the search
+     */
+    search(searchKeyword: string): Promise<any[]>;
+    /**
+     * @description handle the search more event in the provider, when the user scrolls to the bottom of the search result
+     * @param searchQueryText search query text
+     * @param lastLoadedIndex index of the last loaded item
+     * @returns {Promise<Array<MediaItem>>} the result of the search
+     */
+    searchMore(searchQueryText: string, lastLoadedIndex: number): Promise<any[]>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./BaseImageHandler";
+export * from "./BaseVideoHandler";