@cmstops/pro-compo 0.3.55 → 0.3.57

package/es/hooks/assets.d.ts

@@ -0,0 +1 @@
+export declare function useGenerateAssets(BASE_API: string, params: any): import("axios").AxiosPromise<any>;

package/es/hooks/batch.d.ts

@@ -0,0 +1,8 @@
+declare const useTableBatch: () => {
+    hoverTarget: import("vue").Ref<null>;
+    isItemChecked: import("vue").ComputedRef<(selectedData: any, item: any) => any>;
+    hoverBatchBox: import("vue").ComputedRef<(selectedData: any, item: any) => any>;
+    tableCellMouseEnter: (record: any) => void;
+    tableCellMouseLeave: (record: any) => void;
+};
+export default useTableBatch;

package/es/hooks/dialogVisible.d.ts

@@ -0,0 +1,8 @@
+declare type ComponentProps = {
+    visible: boolean;
+};
+export default function useDialogVisible(props: ComponentProps, emit: any): {
+    visible: import("vue").WritableComputedRef<unknown>;
+    setVisible: (bool: boolean) => void;
+};
+export {};

package/es/hooks/source.d.ts

@@ -0,0 +1,9 @@
+interface Params {
+    [key: string]: any;
+}
+export declare function getConfiguration(BASE_API: string, params: Params): import("axios").AxiosPromise<any>;
+declare const useLoadSourceInfo: (BASE_API: string) => {
+    SourceInfo: import("vue").Ref<any>;
+    getSourceInfoHandle: () => Promise<void>;
+};
+export default useLoadSourceInfo;

package/es/hooks/toggle.d.ts

@@ -0,0 +1,6 @@
+export declare function useToggle(initData?: boolean): {
+    state: import("vue").Ref<boolean>;
+    toggle: () => boolean;
+    open: () => boolean;
+    close: () => boolean;
+};

package/es/hooks/useAttachement.d.ts

@@ -0,0 +1,26 @@
+export declare function getAttachmentsAll(BASE_API: string, query?: any): import("axios").AxiosPromise<any>;
+export declare function getAttachmentsMy(BASE_API: string, query?: any): import("axios").AxiosPromise<any>;
+export declare function getAttachmentsMyMessage(BASE_API: string, query: any): import("axios").AxiosPromise<any>;
+declare type OptionsType = {
+    key: string;
+    BASE_API: string;
+};
+export default function useAttachement(options: OptionsType): {
+    list: import("vue").Ref<any[]>;
+    total: import("vue").Ref<number>;
+    limit: import("vue").Ref<number>;
+    offset: import("vue").Ref<number>;
+    pageIdx: import("vue").ComputedRef<number>;
+    loading: import("vue").Ref<boolean>;
+    changeFilter: (f: any) => void;
+    changeKey: (k: string) => void;
+    changePage: (o: number) => void;
+    changeSize: (s: number) => void;
+    loadData: () => Promise<void>;
+};
+export declare function useLocalRecource(): {
+    localList: import("vue").Ref<any[]>;
+    initLocalList: () => void;
+    setLocalList: (list: any[]) => void;
+};
+export {};

package/es/hooks/useLocalStorage.d.ts

@@ -0,0 +1,9 @@
+export declare const LOCALSTORAGE_KEYS: {
+    LOCAL_RESOURCES: string;
+    LOCAL_UPLOAD_CONFIG: string;
+};
+export default function useLocalstorage(key: keyof typeof LOCALSTORAGE_KEYS): {
+    get: () => any;
+    set: (value: any) => void;
+    remove: () => void;
+};

package/es/hooks/useLocalStorage.js

@@ -1,5 +1,6 @@
 const LOCALSTORAGE_KEYS = {
-  LOCAL_RESOURCES: "cmstop-local-resources"
+  LOCAL_RESOURCES: "cmstop-local-resources",
+  LOCAL_UPLOAD_CONFIG: "cmstop-local-upload-config"
 };
 function useLocalstorage(key) {
   function get() {

package/es/hooks/useMediaContext.d.ts

@@ -0,0 +1,12 @@
+export declare function useVideoContext(callback: (data?: any) => any): {
+    options: import("vue").Ref<any[]>;
+    videoContext: import("vue").Ref<HTMLVideoElement | null>;
+    loading: import("vue").Ref<boolean>;
+    playing: import("vue").Ref<boolean>;
+    currentTime: import("vue").Ref<number>;
+    handleOption: (key: string, value: number) => void;
+    togglePlay: () => void;
+    initVideoContext: (selector: string) => void;
+    seekVideo: (time: number) => void;
+    handleOnCanPlay: () => void;
+};

package/es/hooks/usePopper.d.ts

@@ -0,0 +1,8 @@
+import { Placement } from '@popperjs/core';
+import { Ref } from 'vue';
+export default function usePopper(pannel: Ref<HTMLElement | undefined>, triggerEl: Ref<HTMLElement | undefined>): {
+    initPopper: (placement?: Placement) => void;
+    show: () => void;
+    hide: () => void;
+    visible: Ref<boolean>;
+};

package/es/hooks/useSelection.d.ts

@@ -0,0 +1,23 @@
+declare type QueryParams = {
+    limit: number;
+    offset: number;
+    keyword: string;
+    others?: any;
+};
+declare type HookOptionParams = {
+    labelStr: string;
+    valueStr: string;
+    func: (params: QueryParams) => any;
+};
+export default function useSelection(params: HookOptionParams): {
+    options: import("vue").Ref<{
+        label: string;
+        value: any;
+    }[]>;
+    loading: import("vue").Ref<boolean>;
+    keyword: import("vue").Ref<string>;
+    load: (more?: boolean | undefined) => Promise<void>;
+    handleSearch: (kw: string) => void;
+    loadMore: () => void;
+};
+export {};

package/es/hooks/useUpload.d.ts

@@ -0,0 +1,29 @@
+export declare type CallbackFunc = (data: any, status?: 'success' | 'fail') => void;
+export declare type TypeAddMediaParam = {
+    url: string;
+    alias: string;
+    catalog: string;
+    repository_id: number;
+    directory_id: number;
+    size: number;
+};
+export declare function getSize(value: number): string;
+export declare function addMedia(BASE_API: string, params: TypeAddMediaParam): import("axios").AxiosPromise<any>;
+export declare function reTranscodeMedia(BASE_API: string, media_id: number): import("axios").AxiosPromise<any>;
+declare type UploadOptions = {
+    noAddMedia: boolean;
+};
+export default function useUpload(options?: UploadOptions): {
+    list: import("vue").Ref<any[]>;
+    uploadFile: (BASE_API: string, file: any, dir: number | undefined, repoId: number, callback?: CallbackFunc | undefined) => void;
+    reTranscode: (BASE_API: string, file: any) => Promise<boolean>;
+    transcodingFile: (BASE_API: string, file: any) => void;
+    recordTaskStatusChange: (file: any, progress: number, isTrans?: boolean | undefined) => void;
+    removeRecord: (file: any) => void;
+};
+export declare function useUploadConfig(): {
+    config: import("vue").Ref<any>;
+    checkFileSizeOutLimit: (file: File, callback: (msg: string) => void) => boolean;
+    initUploadConfig: (BASE_API: string, domainId: number) => Promise<void>;
+};
+export {};

package/es/hooks/useUpload.js

@@ -4,6 +4,17 @@ import { TusUploadTask } from "../utils/tusUpload.js";
 import request from "../utils/request.js";
 import { TranscodingTask } from "../utils/transcodeMedia.js";
 import useLocalstorage from "./useLocalStorage.js";
+function getSize(value) {
+  if (!value)
+    return "";
+  let i = -1;
+  const byteUnits = [" KB", " MB", " GB", " TB", " PB", " EB", " ZB", " YB"];
+  do {
+    value /= 1024;
+    i++;
+  } while (value > 1024);
+  return value.toFixed(2) + byteUnits[i];
+}
 function addMedia(BASE_API, params) {
   return request(BASE_API, {
     url: "/poplar/v2/media/add",
@@ -18,7 +29,7 @@ function reTranscodeMedia(BASE_API, media_id) {
     data: { media_id }
   });
 }
-function useUpload() {
+function useUpload(options) {
   const { get, set, remove } = useLocalstorage("LOCAL_RESOURCES");
   const list = ref(get() || []);
   function uploadSuccess(file) {
@@ -76,6 +87,11 @@ function useUpload() {
     };
     const uploading = upload.start(progress);
     uploading.then(async (url) => {
+      if (options == null ? void 0 : options.noAddMedia) {
+        recordTaskStatusChange({ ...newFile, status: 0, url }, 1);
+        callback && callback({ ...newFile, url }, "success");
+        return;
+      }
       const { code, message } = await addMedia(BASE_API, {
         url,
         size: newFile.size,
@@ -150,7 +166,7 @@ function useUpload() {
     }
   };
   watch(() => list.value, set, { deep: true });
-  window.onbeforeunload = remove;
+  window.addEventListener("beforeunload", remove, false);
   return {
     list,
     uploadFile,
@@ -160,4 +176,69 @@ function useUpload() {
     removeRecord
   };
 }
-export { addMedia, useUpload as default, reTranscodeMedia };
+function getConfiguration(BASE_API, params) {
+  return request(BASE_API, {
+    url: `poplar/v2/settings`,
+    method: "get",
+    params
+  });
+}
+function useUploadConfig() {
+  const { get, set, remove } = useLocalstorage("LOCAL_UPLOAD_CONFIG");
+  const config = ref(get() || {});
+  async function initUploadConfig(BASE_API, domainId) {
+    if (config.value.size_config_enabled != null)
+      return;
+    try {
+      const { code, message } = await getConfiguration(BASE_API, {
+        domain_id: domainId,
+        module: "platform",
+        key: "size",
+        cloud: true
+      });
+      if (code !== 0)
+        return;
+      const [{ value }] = message;
+      config.value = JSON.parse(value);
+      set(value);
+    } catch (e) {
+      console.log("\u4E0A\u4F20\u914D\u7F6E\u83B7\u53D6\u5931\u8D25", e);
+    }
+  }
+  function checkFileSizeOutLimit(file, callback) {
+    if (!file)
+      return true;
+    const { type, size, name } = file;
+    const { file_size, image_size, video_size, audio_size, enable } = config.value;
+    let typeCN = "";
+    let limitSize = file_size;
+    if (!enable)
+      return true;
+    if (type.startsWith("image")) {
+      typeCN = "\u56FE\u7247";
+      limitSize = image_size;
+    } else if (type.startsWith("video")) {
+      typeCN = "\u89C6\u9891";
+      limitSize = video_size;
+    } else if (type.startsWith("audio")) {
+      typeCN = "\u97F3\u9891";
+      limitSize = audio_size;
+    } else {
+      limitSize = file_size;
+    }
+    if (size <= limitSize) {
+      return true;
+    }
+    callback(
+      `"${name}" \u592A\u5927\uFF0C\u8BF7\u4E0A\u4F20\u4E0D\u5927\u4E8E ${getSize(limitSize)} \u7684 ${typeCN} \u6587\u4EF6\u3002`
+    );
+    return false;
+  }
+  window.addEventListener("beforeunload", remove, false);
+  return {
+    config,
+    checkFileSizeOutLimit,
+    initUploadConfig
+  };
+}
+export { addMedia, useUpload as default, getSize, reTranscodeMedia, useUploadConfig };

package/es/hooks/user.d.ts

@@ -0,0 +1,9 @@
+interface Params {
+    [key: string]: any;
+}
+export declare function getChannels(BASE_API: string, params?: Params): import("axios").AxiosPromise<any>;
+declare const useLoadUserInfo: (BASE_API: string) => {
+    userInfo: import("vue").Ref<any>;
+    getUserInfoHandle: () => Promise<void>;
+};
+export default useLoadUserInfo;

package/es/imageCrop/index.d.ts

@@ -0,0 +1,2 @@
+declare const imageCrop: any;
+export default imageCrop;

package/es/imageCrop/script/api.d.ts

@@ -0,0 +1 @@
+export declare function getFileRealUrl(BASE_API: string, url: string): import("axios").AxiosPromise<any>;