@aliyun-obv/api 0.0.41 → 0.0.43

package/dist/api.d.ts

@@ -1,24 +1,58 @@
-interface BaseFetchDefault {
+import { ShowConfig } from '@alifd/next/types/dialog';
+
+interface IBaseFetchOptions {
+    forbidAlert?: boolean;
+    headers?: HeadersInit;
+}
+interface IErrorRequest {
+    method: string;
+    api: string;
+    params: string;
+}
+interface BaseFetchDefault<OP extends IBaseFetchOptions> {
     baseURL?: string;
     getDefaultInit: RequestInit;
     postDefaultInit: RequestInit;
-    beforeRequest?: (url: string, init: RequestInit) => RequestInit;
-    afterResponse?: (response: Response, options: BaseFetchOptions) => any;
-}
-interface BaseFetchOptions {
-    forbidAlert?: boolean;
-    headers?: HeadersInit;
+    putDefaultInit: RequestInit;
+    beforeRequest?: (url: string, params: Record<string, any>, init: RequestInit, options?: OP) => Promise<{
+        url: string;
+        init: RequestInit;
+    }>;
+    afterResponse?: (response: any, options?: OP) => Promise<any>;
+    errorHandler?: (request: IErrorRequest, error: any, options?: OP) => any;
 }
-type IFetchAPI = (input: string, init?: RequestInit, options?: BaseFetchOptions) => Promise<any>;
-declare class BaseFetch<R> {
+type IFetchAPI<OP extends IBaseFetchOptions> = (input: string, init?: RequestInit, options?: OP) => Promise<any>;
+declare class BaseFetch<OP extends IBaseFetchOptions, R> {
     private fetchApi;
-    defaults: BaseFetchDefault;
-    constructor(fetchApi?: IFetchAPI);
+    defaults: BaseFetchDefault<IBaseFetchOptions>;
+    constructor(fetchApi?: IFetchAPI<OP>);
+    private beforeRequest;
     private callFetch;
-    get(api: string, params?: Record<string, any>, options?: BaseFetchOptions): Promise<R>;
-    post(api: string, config?: Record<string, any>, options?: BaseFetchOptions): Promise<R>;
+    get(api: string, params?: Record<string, any>, options?: OP): Promise<R>;
+    private _post;
+    post(api: string, params?: Record<string, any>, options?: OP): Promise<R>;
+    put(api: string, params?: Record<string, any>, options?: OP): Promise<R>;
 }
 
+interface ISLSFetchOptions extends IBaseFetchOptions {
+    /**
+     * 如果 url 上有 slsRegion 参数，默认会使用，如果 ingoreSlsRegion 为 true，此时不启用
+     */
+    ingoreSlsRegion?: boolean;
+    /**
+     * project region, 配置后会在 header 中添加 sls-region，用于 console 直连该 region
+     */
+    region?: string;
+    /**
+     * 'Content-Type': 'application/json'
+     */
+    restful?: boolean;
+    /**
+     * 隐藏错误弹窗
+     */
+    hideErrorAlert?: boolean;
+    forbidAlert?: boolean;
+}
 interface IResponseData {
     [x: string]: any;
     res: any;
@@ -28,9 +62,155 @@ interface IResponseData {
     message: any;
     response: Response;
 }
+
+/**
+ * For Obs EndPoint
+ */
+declare const obsEasyFetch: BaseFetch<ISLSFetchOptions, IResponseData>;
+
+/**
+ * For Common EndPoint
+ */
+declare const commonEasyFetch: BaseFetch<IBaseFetchOptions, IResponseData>;
+
 /**
  * For SLS EndPoint
  */
-declare const easyFetch: BaseFetch<IResponseData>;
+declare const slsEasyFetch: BaseFetch<ISLSFetchOptions, IResponseData>;
+
+/**
+ * 全局错误处理函数
+ * @param config
+ *           content: 内容
+ *           title: 标题
+ * @param response easyfeatch 返回体
+ * @returns
+ */
+declare function showAlertDialog(response: any, config?: ShowConfig, request?: any): boolean;
+declare function showAlertDialogWhenNeedLogin(response: any, config?: {}): void;
+
+declare namespace metaService {
+    export interface GetMetaRecordParameters {
+        name: string;
+        recordId: string;
+    }
+    export function getMetaRecord(params: GetMetaRecordParameters): Promise<IResponseData>;
+    export interface ListMetaRecordParameters {
+        name: string;
+        jsonPath?: string;
+        jsonPathValue?: string;
+        size?: number;
+        page?: number;
+    }
+    export function listMetaRecord(params: ListMetaRecordParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export interface CreateMetaResourceParameters {
+        name: string;
+        type: string;
+        description: string;
+        schema?: any;
+    }
+    export function createMetaResource(params: CreateMetaResourceParameters): Promise<IResponseData>;
+    export interface CreateMetaRecordParameters {
+        name: string;
+        record: {
+            id?: string;
+            tag?: string;
+            value: any;
+        };
+    }
+    export function createMetaRecord({ name, record }: CreateMetaRecordParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export function updataMetaRecord({ name, record }: CreateMetaRecordParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export function listMetaRecordWithIdentity(params: ListMetaRecordParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export function getMetaRecordWithIdentity(params: GetMetaRecordParameters): Promise<IResponseData>;
+    export function updataMetaRecordWithIdentity({ name, record }: CreateMetaRecordParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export interface DeleteMetaRecordsParameters {
+        name: string;
+        recordIds: string;
+    }
+    export function deleteRecords(config?: DeleteMetaRecordsParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export function deleteRecordsWithIdentity(config?: DeleteMetaRecordsParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export interface DeleteMetaResource {
+        name: string;
+    }
+    export function deleteResource(params: DeleteMetaResource): Promise<IResponseData>;
+    interface Config {
+        order: number;
+    }
+    interface Value {
+        project: string;
+        dashboard: string;
+        value: string;
+        update: number;
+        version: string;
+        config: Config;
+    }
+    export interface Record {
+        value: Value;
+    }
+    export interface CreateSomeMetaRecordsParameters {
+        name: string;
+        records: Record[];
+    }
+    export function createSomeMetaRecordsWithIdentity({ name, records }: CreateSomeMetaRecordsParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export function createSomeMetaRecords({ name, records }: CreateSomeMetaRecordsParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export interface LogstoreIndexParameters {
+        project: string;
+        dashboard: string;
+        version?: string;
+    }
+    export interface NewLogstoreIndexParameters {
+        name: string;
+        jsonPath?: string;
+        jsonPathValue?: string;
+        page?: number;
+        size?: number;
+    }
+    export function getNewDashboardList({ name, jsonPath, jsonPathValue, page, size }: NewLogstoreIndexParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export function getNewDashboardListWithIdentity({ name, jsonPath, jsonPathValue, page, size }: NewLogstoreIndexParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export interface DeleteRecordsParameters {
+        name: string;
+        recordIds: string;
+    }
+    export function deleteVersionRecords({ name, recordIds }: DeleteRecordsParameters, forbidAlert?: boolean): Promise<IResponseData>;
+    export const ckeckPermissionForList: (resourceName: string) => Promise<boolean>;
+    export {};
+}
+
+declare namespace workSpaceService {
+    export interface GetWorkspaceRecordParameters {
+        workspaceId: string;
+    }
+    export function getWorkspaceRecord(params: GetWorkspaceRecordParameters): Promise<IResponseData>;
+    export interface GetWorkSpaceList {
+        type: string;
+        page: number;
+        pageSize: number;
+    }
+    export function getWorkspacelist(params: GetWorkSpaceList): Promise<IResponseData>;
+    export interface GetWorkspaceInforProps {
+        id: string;
+    }
+    export function getWorkspaceInfor(params: GetWorkspaceInforProps): Promise<IResponseData>;
+    export interface createItomInstance {
+        workspace: string;
+        project: string;
+        version: string;
+        appType: string;
+    }
+    export function createInstance(params: createItomInstance): Promise<IResponseData>;
+    export interface UpdataAppInstanceProps {
+        workspaceId: string;
+        app: any;
+    }
+    export function updataAppInstance(params: UpdataAppInstanceProps): Promise<IResponseData>;
+    type GetWorkspaceForITOMProps = {
+        instanceId: string;
+        project: string;
+        aliasId: string;
+        size?: number;
+    };
+    export function getWorkspaceForITOM(params: GetWorkspaceForITOMProps): Promise<IResponseData>;
+    export {};
+}
 
-export { easyFetch };
+export { commonEasyFetch, metaService, obsEasyFetch, showAlertDialog, showAlertDialogWhenNeedLogin, slsEasyFetch, workSpaceService };

package/dist/api.es.js

@@ -1,4 +1,11 @@
 import _ from 'lodash';
+import errorPrompt from '@alicloud/console-base-error-prompt-proxy';
+import i18n, { getMsg } from '@aliyun-obv/i18n';
+import urijs from 'urijs';
+import { Dialog, Button, Message } from '@alifd/next';
+import { slsConsoleRuntime, commonUtil, urlUtil, addStubForSearch, addRUMLog } from '@aliyun-obv/utils';
+import React from 'react';
+import merge from 'lodash/merge';
 
 function getParams(obj = {}) {
   return Object.keys(obj).filter((k) => obj[k] || +obj[k] === 0).map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(obj[k])}`).join("&");
@@ -14,13 +21,27 @@ function getPostParam(obj = {}) {
   }).join("&");
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
 var __publicField = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-var __async$1 = (__this, __arguments, generator) => {
+var __async$5 = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -40,6 +61,7 @@ var __async$1 = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
+const isTest = process.env.NODE_ENV === "test";
 class BaseFetch {
   constructor(fetchApi) {
     __publicField(this, "fetchApi");
@@ -53,13 +75,35 @@ class BaseFetch {
       postDefaultInit: {
         method: "post",
         credentials: "same-origin",
-        headers: {}
+        headers: {
+          Accept: "application/json"
+        }
+      },
+      putDefaultInit: {
+        method: "post",
+        credentials: "same-origin",
+        headers: {
+          Accept: "application/json"
+        }
       }
     });
     this.fetchApi = fetchApi;
   }
+  beforeRequest(api, params, init, options) {
+    const hasBaseURL = typeof this.defaults.baseURL === "string" && this.defaults.baseURL.trim().length > 0;
+    let url = api;
+    let newInit = init;
+    if (hasBaseURL) {
+      url = `${this.defaults.baseURL}${url}`;
+      newInit = __spreadValues$4({}, Object.assign({}, init, { credentials: "include" }));
+    }
+    if (this.defaults.beforeRequest) {
+      return this.defaults.beforeRequest(url, params, newInit, options);
+    }
+    return { url, init: newInit };
+  }
   callFetch(_0, _1) {
-    return __async$1(this, arguments, function* (api, init, options = {}) {
+    return __async$5(this, arguments, function* (api, init, options = {}) {
       let headers = init == null ? void 0 : init.headers;
       if (options.headers) {
         headers = Object.assign({}, init == null ? void 0 : init.headers, options.headers);
@@ -71,31 +115,653 @@ class BaseFetch {
     });
   }
   get(_0) {
-    return __async$1(this, arguments, function* (api, params = {}, options = {}) {
-      const url = `${api}?${getParams(params)}`;
-      const fetchInit = this.defaults.getDefaultInit;
-      const res = yield this.callFetch(url, fetchInit, options);
-      if (this.defaults.afterResponse) {
-        return this.defaults.afterResponse(res, options);
+    return __async$5(this, arguments, function* (api, params = {}, options = {}) {
+      if (isTest)
+        return Promise.resolve({ res: void 0 });
+      try {
+        const { url: newApi, init: newInit } = yield this.beforeRequest(
+          api,
+          params,
+          this.defaults.getDefaultInit,
+          options
+        );
+        const url = `${newApi}?${getParams(params)}`;
+        const res = yield this.callFetch(url, newInit, options);
+        if (this.defaults.afterResponse) {
+          return yield this.defaults.afterResponse(res, options);
+        }
+        return res;
+      } catch (error) {
+        if (this.defaults.errorHandler) {
+          return this.defaults.errorHandler(
+            { method: "GET", api, params: getParams(params) },
+            error,
+            options
+          );
+        }
+        throw error;
       }
-      return res;
     });
   }
-  post(_0) {
-    return __async$1(this, arguments, function* (api, config = {}, options = {}) {
+  _post(_0) {
+    return __async$5(this, arguments, function* (api, params = {}, options = {}, defaultInit) {
       var _a;
-      const contentType = ((_a = options == null ? void 0 : options.headers) == null ? void 0 : _a["Content-Type"]) || "application/x-www-form-urlencoded";
-      const fetchInit = _.merge({}, this.defaults.postDefaultInit, {
-        body: contentType.includes("application/json") ? JSON.stringify(config) : getPostParam(config)
-      });
-      const res = yield this.callFetch(api, fetchInit, options);
-      if (this.defaults.afterResponse) {
-        return this.defaults.afterResponse(res, options);
+      if (isTest)
+        return Promise.resolve({ res: void 0 });
+      try {
+        const contentType = ((_a = options == null ? void 0 : options.headers) == null ? void 0 : _a["Content-Type"]) || "application/x-www-form-urlencoded";
+        const fetchInit = _.merge({}, defaultInit, {
+          body: contentType.includes("application/json") ? JSON.stringify(params) : getPostParam(params)
+        });
+        const { url: newApi, init: newInit } = yield this.beforeRequest(api, params, fetchInit, options);
+        const res = yield this.callFetch(newApi, newInit, options);
+        if (this.defaults.afterResponse) {
+          return yield this.defaults.afterResponse(res, options);
+        }
+        return res;
+      } catch (error) {
+        if (this.defaults.errorHandler) {
+          return this.defaults.errorHandler(error, options);
+        }
+        throw error;
       }
-      return res;
     });
   }
+  post(_0) {
+    return __async$5(this, arguments, function* (api, params = {}, options = {}) {
+      return this._post(api, params, options, this.defaults.postDefaultInit);
+    });
+  }
+  put(_0) {
+    return __async$5(this, arguments, function* (api, params = {}, options = {}) {
+      return this._post(api, params, options, this.defaults.putDefaultInit);
+    });
+  }
+}
+
+function getConfig(key) {
+  window.ALIYUN_SLS_CONSOLE_CONFIG = window.ALIYUN_SLS_CONSOLE_CONFIG || {};
+  return window.ALIYUN_SLS_CONSOLE_CONFIG[key] !== void 0 ? window.ALIYUN_SLS_CONSOLE_CONFIG[key] : "";
+}
+function extraActionAndResource(message) {
+  var _a;
+  const arr = (_a = message.match(/denied by sts or ram[\S\s]+action:\s(\S+:\S+),[\S\s]+resource:\s(\S+)/)) != null ? _a : [];
+  if (arr.length === 3) {
+    return {
+      action: arr[1],
+      resource: arr[2]
+    };
+  } else {
+    return {
+      action: "",
+      resource: ""
+    };
+  }
+}
+function convertErrorDetaisAuth(o) {
+  if (!o) {
+    return;
+  }
+  return {
+    type: o.NoPermissionType,
+    action: o.AuthAction,
+    resource: o.AuthResource,
+    userType: o.AuthPrincipalType,
+    userName: o.AuthPrincipalDisplayName,
+    userId: o.AuthPrincipalOwnerId,
+    policyType: o.PolicyType,
+    diagnosisInfo: o.EncodedDiagnosticMessage
+  };
+}
+function createNoXSS(htmlString) {
+  return htmlString.substr(0, 400);
+}
+const errorMsgHandler = (err) => {
+  let msg = window.ALIYUN_SLS_CONSOLE_MESSAGE && window.ALIYUN_SLS_CONSOLE_MESSAGE[err.code];
+  if (err.code === "OnlyInternalAccess") {
+    return err.message;
+  }
+  if (err.message === "Failed to fetch") {
+    msg = i18n.ERRMESSAGE4;
+  }
+  if (err.message && err.message.indexOf("Specified ArgValue is malformed") > -1) {
+    msg = i18n.ERRMESSAGE2;
+  }
+  return createNoXSS(msg || err.message || i18n.ERRMESSAGE3);
+};
+function getOauthCallbackUrl(url = window.location.href) {
+  return `https:${slsConsoleRuntime.links.ACCOUNT}/login/login.htm?oauth_callback=${url}`;
+}
+function createNoPermissionContent() {
+  return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("div", { className: "sls-custom-container" }, /* @__PURE__ */ React.createElement("div", { className: "sls-custom-title" }, i18n.UNAUTHORIZEDOPERMSG)));
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __async$4 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const commonEasyFetch = new BaseFetch();
+commonEasyFetch.defaults.postDefaultInit.headers["Content-Type"] = "application/x-www-form-urlencoded";
+commonEasyFetch.defaults.postDefaultInit.headers["Accept"] = "application/json";
+commonEasyFetch.defaults.afterResponse = (response) => __async$4(void 0, null, function* () {
+  if (response.status >= 200 && response.status < 300) {
+    const data = yield response.json();
+    return __spreadProps$3(__spreadValues$3({}, data != null ? data : {}), {
+      response
+    });
+  } else {
+    throw new Error(response.statusText);
+  }
+});
+
+const ERROR_TITLE = i18n.ERROR;
+i18n.OK;
+let isGlobalAlertShow = false;
+function showConsoleBaseAlertDialog(response, config = {}, request) {
+  var _a, _b, _c;
+  if ((response == null ? void 0 : response.code) === "200") {
+    return false;
+  }
+  const errorConfig = {
+    title: ERROR_TITLE,
+    // 错误
+    message: response.message,
+    code: response.code,
+    requestId: response.requestId,
+    details: {
+      url: request ? request.api : void 0,
+      method: request ? request.method : void 0
+    }
+  };
+  if (response.code === "ShowUnauthorized") {
+    if ((_a = response == null ? void 0 : response.rawResponseError) == null ? void 0 : _a.accessDeniedDetail) {
+      const detailsAuth = convertErrorDetaisAuth(response.rawResponseError.accessDeniedDetail);
+      errorConfig.detailsAuth = detailsAuth;
+      errorConfig.code = ((_b = response == null ? void 0 : response.rawResponseError) == null ? void 0 : _b.errorCode) || "Unauthorized";
+      errorPrompt(errorConfig);
+    } else {
+      const { action, resource } = extraActionAndResource(response.message);
+      if (errorConfig.details) {
+        errorConfig.details.ACTION = action;
+        errorConfig.details.RESOURCE = resource;
+      }
+      errorConfig.code = ((_c = response == null ? void 0 : response.rawResponseError) == null ? void 0 : _c.errorCode) || "Unauthorized";
+      errorPrompt(errorConfig, config, true);
+    }
+  } else {
+    errorPrompt(errorConfig, config, true);
+  }
+  return true;
+}
+function showCSRFDialog(config) {
+  const dialog = Dialog.alert({
+    content: i18n.ERRMESSAGE1,
+    title: ERROR_TITLE,
+    className: "cdnext-alert cdnext-error-alert",
+    afterClose: () => {
+      isGlobalAlertShow = false;
+      if (config.afterClose) {
+        config.afterClose();
+      }
+    },
+    footer: [
+      /* @__PURE__ */ React.createElement(
+        Button,
+        {
+          type: "primary",
+          onClick: () => {
+            commonEasyFetch.get("/console/ajax/getSecToken.json").then((res) => {
+              if ((res == null ? void 0 : res.code) === "200") {
+                window.ALIYUN_SLS_CONSOLE_CONFIG.SEC_TOKEN = res.data;
+                dialog.hide();
+              }
+            }).catch(() => {
+            });
+          }
+        },
+        i18n.REFRESH
+      )
+    ]
+  });
+}
+function showNeedLoginDialog(config) {
+  const parseQuery = urijs(location.search).escapeQuerySpace(false).query(true);
+  if (commonUtil.judgeIframe() && parseQuery.reloadParent === "true") {
+    try {
+      const mockWindow = parent.parent.window;
+      const mockLocation = mockWindow.location;
+      mockLocation.href = decodeURIComponent(urlUtil.getParentUrl());
+      return;
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  let loginUrl = getOauthCallbackUrl(
+    `${window.location.origin}/lognext/exit${addStubForSearch("", true)}`
+  );
+  if (parseQuery.customLoginUrl && parseQuery.customLoginUrl !== "") {
+    loginUrl = decodeURIComponent(parseQuery.customLoginUrl);
+  }
+  const dialog = Dialog.alert({
+    content: getMsg("lb.login_time_out_content"),
+    title: getMsg("lb.login_time_out_title"),
+    className: "cdnext-alert cdnext-error-alert",
+    afterClose: () => {
+      isGlobalAlertShow = false;
+      if (config.afterClose) {
+        config.afterClose();
+      }
+    },
+    footer: [
+      /* @__PURE__ */ React.createElement(
+        Button,
+        {
+          type: "primary",
+          style: { marginRight: "8px" },
+          onClick: () => {
+            addRUMLog({
+              spm_main: "login_dialog",
+              spm_btn_type: "login",
+              spm_loginUrl: loginUrl
+            });
+            window.open(loginUrl, "_blank");
+          },
+          key: "login"
+        },
+        getMsg("lb.login_time_out_new_window")
+      ),
+      /* @__PURE__ */ React.createElement(
+        Button,
+        {
+          onClick: () => {
+            addRUMLog({
+              spm_main: "login_dialog",
+              spm_btn_type: "getSecToken",
+              spm_loginUrl: loginUrl
+            });
+            commonEasyFetch.get("/console/ajax/getSecToken.json").then((res) => {
+              if (res && res.code === "200") {
+                window.ALIYUN_SLS_CONSOLE_CONFIG.SEC_TOKEN = res.data;
+                dialog.hide();
+              } else {
+                Message.error(getMsg("lb.login_time_out"));
+              }
+            }).catch(() => {
+            });
+          },
+          key: "getSecToken"
+        },
+        getMsg("lb.login_time_out_finished")
+      )
+    ]
+  });
 }
+function showAlertDialog(response, config = {}, request) {
+  if (isGlobalAlertShow || response == null) {
+    return false;
+  }
+  if ((response == null ? void 0 : response.code) === "200") {
+    return false;
+  }
+  if (config.content == null || config.content === "") {
+    config.content = errorMsgHandler(response);
+  }
+  if (response.code === "CsrfTokenError") {
+    isGlobalAlertShow = true;
+    showCSRFDialog(config);
+    return true;
+  }
+  if (response.code === "ConsoleNeedLogin") {
+    isGlobalAlertShow = true;
+    showNeedLoginDialog(response);
+    return true;
+  }
+  const _params = {
+    title: ERROR_TITLE,
+    message: /* @__PURE__ */ React.createElement("div", null, config.content ? config.content : "")
+  };
+  showConsoleBaseAlertDialog(response, _params, request);
+  return true;
+}
+function showAlertDialogWhenNeedLogin(response, config = {}) {
+  if (response != null && response.code === "ConsoleNeedLogin") {
+    showAlertDialog(response, config);
+  }
+}
+const errorHandler = (request, error, options) => {
+  var _a;
+  if (error.code === "IndexConfigNotExist" && error.message && (request.api === "/console/logstoreindex/getLogs.json" || request.api === "/console/logstoreindex/getHistograms.json")) {
+    if (options && "product" in options && options.product !== "") {
+      showAlertDialog(
+        error,
+        {
+          content: i18n.PRODUCTMESSAGE
+        },
+        request
+      );
+    } else {
+      showAlertDialog(
+        error,
+        {
+          content: errorMsgHandler(error)
+        },
+        request
+      );
+    }
+  } else {
+    if (error.code === "ShowUnauthorized") {
+      if ((_a = error == null ? void 0 : error.rawResponseError) == null ? void 0 : _a.accessDeniedDetail) {
+        showAlertDialog(
+          error,
+          {
+            content: errorMsgHandler(error)
+          },
+          request
+        );
+      } else {
+        showAlertDialog(
+          error,
+          {
+            content: createNoPermissionContent(),
+            className: "sls-custom-dialog"
+          },
+          request
+        );
+      }
+    } else {
+      showAlertDialog(
+        error,
+        {
+          content: errorMsgHandler(error)
+        },
+        request
+      );
+    }
+    return "";
+  }
+  let errorMessage = error.message;
+  throw errorMessage;
+};
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __async$3 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+let slsAccessToken = window.ALIYUN_SLS_CONSOLE_CONFIG.slsAccessToken;
+let slsAccessTokenMode = false;
+const urlQueryObj = urijs(location.search).escapeQuerySpace(false).query(true);
+const supportRefreshToken = urlQueryObj.supportRefreshToken === "true" && window.top !== window.self && parent != null;
+try {
+  if (window.ALIYUN_CONSOLE_CONFIG.ENV === "pre") {
+    if (urlQueryObj.slsAccessToken) {
+      slsAccessToken = urlQueryObj.slsAccessToken;
+    }
+  }
+} catch (error) {
+}
+if (Object.prototype.toString.call(slsAccessToken) === "[object String]" && slsAccessToken.length > 0) {
+  slsAccessTokenMode = true;
+}
+let tokenRefreshing = false;
+let refreshPromisesQueue = [];
+function waitRefreshToken() {
+  return new Promise((resolve) => {
+    refreshPromisesQueue.push(resolve);
+    if (!tokenRefreshing) {
+      tokenRefreshing = true;
+      parent.postMessage({ type: "refreshToken", ticket: urlQueryObj.sls_ticket }, "*");
+      window.addEventListener(
+        "message",
+        (event) => {
+          var _a, _b, _c;
+          try {
+            if (((_a = event == null ? void 0 : event.data) == null ? void 0 : _a.type) === "applyAccessToken" && ((_b = event == null ? void 0 : event.data) == null ? void 0 : _b.ticket) === urlQueryObj.sls_ticket) {
+              slsAccessToken = (_c = event == null ? void 0 : event.data) == null ? void 0 : _c.accessToken;
+              tokenRefreshing = false;
+              const queue = refreshPromisesQueue;
+              refreshPromisesQueue = [];
+              queue.forEach((rl) => {
+                rl(void 0);
+              });
+            }
+          } catch (error) {
+            console.error(error);
+          }
+        },
+        { once: true }
+      );
+    }
+  });
+}
+function _finalFetch(api, fetchOptions, deep = 0) {
+  return __async$3(this, null, function* () {
+    const requestApi = api;
+    if (tokenRefreshing) {
+      yield waitRefreshToken();
+    }
+    if (slsAccessTokenMode) {
+      fetchOptions.headers = __spreadProps$2(__spreadValues$2({}, fetchOptions.headers || {}), {
+        slsAccessToken
+      });
+    }
+    const response = yield fetch(requestApi, fetchOptions);
+    if (response.status >= 200 && response.status < 300) {
+      const data = yield response.json();
+      if (slsAccessTokenMode && supportRefreshToken && deep < 3) {
+        if (data.code === "ExpiredToken") {
+          yield waitRefreshToken();
+          return _finalFetch(api, fetchOptions, deep + 1);
+        }
+      }
+      return {
+        response,
+        data
+      };
+    } else {
+      throw new Error(response.statusText);
+    }
+  });
+}
+function finalFetch(api, fetchOptions, options) {
+  return __async$3(this, null, function* () {
+    let finalOption = fetchOptions;
+    const parseQuery = urijs(decodeURIComponent(location.search)).escapeQuerySpace(false).query(true);
+    if (parseQuery.slsRegion && options.ingoreSlsRegion) {
+      finalOption = merge({}, finalOption, {
+        headers: {
+          "Sls-Region": parseQuery.slsRegion
+        }
+      });
+    }
+    if (options.region && options.region.trim() !== "") {
+      finalOption = merge({}, finalOption, {
+        headers: {
+          "Sls-Region": options.region
+        }
+      });
+    }
+    return _finalFetch(api, finalOption);
+  });
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __async$2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const slsEasyFetch = new BaseFetch(finalFetch);
+slsEasyFetch.defaults.postDefaultInit.headers["Content-Type"] = "application/x-www-form-urlencoded";
+slsEasyFetch.defaults.postDefaultInit.headers["Accept"] = "application/json";
+slsEasyFetch.defaults.errorHandler = errorHandler;
+slsEasyFetch.defaults.beforeRequest = (url, params, init, options) => __async$2(void 0, null, function* () {
+  var _a;
+  const method = (_a = init.method) == null ? void 0 : _a.toLowerCase();
+  if (method === "post" || method === "put") {
+    let newInit = init;
+    if (options == null ? void 0 : options.restful) {
+      newInit = merge({}, init, {
+        headers: {
+          "X-CSRF-TOKEN": getConfig("SEC_TOKEN"),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(params)
+      });
+    } else {
+      newInit = merge({}, init, {
+        headers: {
+          "X-CSRF-TOKEN": getConfig("SEC_TOKEN")
+        }
+      });
+    }
+    return {
+      url,
+      init: newInit
+    };
+  } else {
+    return {
+      url,
+      init
+    };
+  }
+});
+slsEasyFetch.defaults.afterResponse = (r, options) => __async$2(void 0, null, function* () {
+  const { response, data } = r;
+  let composedData = __spreadProps$1(__spreadValues$1({}, data), {
+    response
+  });
+  let hasError = false;
+  if (response.url.indexOf("/console/logs/getLogs.json") !== -1) {
+    const newData = Object.assign({}, data, response.headers.get("x-log-requestid"));
+    composedData = __spreadProps$1(__spreadValues$1({}, newData), {
+      response
+    });
+    if (newData.code && newData.code.toString() !== "200") {
+      hasError = true;
+    }
+  } else {
+    if (data.code && data.code.toString() === "200") ; else {
+      hasError = true;
+    }
+  }
+  if ((options == null ? void 0 : options.forbidAlert) || (options == null ? void 0 : options.hideErrorAlert)) {
+    return composedData;
+  }
+  if (hasError) {
+    throw composedData;
+  }
+  return composedData;
+});
+
+const obsEasyFetch = new BaseFetch(finalFetch);
+obsEasyFetch.defaults.postDefaultInit.headers["Content-Type"] = "application/x-www-form-urlencoded";
+obsEasyFetch.defaults.postDefaultInit.headers["Accept"] = "application/json";
+obsEasyFetch.defaults.errorHandler = errorHandler;
+obsEasyFetch.defaults.beforeRequest = slsEasyFetch.defaults.beforeRequest;
+obsEasyFetch.defaults.afterResponse = slsEasyFetch.defaults.afterResponse;
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -116,6 +782,234 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var metaService;
+((metaService2) => {
+  function getMetaRecord(params) {
+    return __async$1(this, null, function* () {
+      return slsEasyFetch.get("/console/metaRecordAjax/get.json", params);
+    });
+  }
+  metaService2.getMetaRecord = getMetaRecord;
+  function listMetaRecord(params, forbidAlert = false) {
+    return __async$1(this, null, function* () {
+      return slsEasyFetch.get(
+        "/console/metaRecordAjax/list.json",
+        __spreadProps(__spreadValues({}, params), {
+          page: params.page || 1,
+          size: params.size || 100
+        }),
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.listMetaRecord = listMetaRecord;
+  function createMetaResource(params) {
+    return __async$1(this, null, function* () {
+      return slsEasyFetch.post("/console/metaResourceAjax/create.json", params);
+    });
+  }
+  metaService2.createMetaResource = createMetaResource;
+  function createMetaRecord(_0) {
+    return __async$1(this, arguments, function* ({ name, record }, forbidAlert = false) {
+      const recordObj = __spreadProps(__spreadValues({}, record), {
+        value: JSON.stringify(record.value)
+      });
+      return slsEasyFetch.post(
+        "/console/metaRecordAjax/create.json",
+        {
+          name,
+          record: JSON.stringify(recordObj)
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.createMetaRecord = createMetaRecord;
+  function updataMetaRecord(_0) {
+    return __async$1(this, arguments, function* ({ name, record }, forbidAlert = false) {
+      const recordObj = __spreadProps(__spreadValues({}, record), {
+        value: JSON.stringify(record.value)
+      });
+      return slsEasyFetch.post(
+        "/console/metaRecordAjax/update.json",
+        {
+          name,
+          record: JSON.stringify(recordObj)
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.updataMetaRecord = updataMetaRecord;
+  function listMetaRecordWithIdentity(params, forbidAlert = false) {
+    return __async$1(this, null, function* () {
+      return slsEasyFetch.get(
+        "/console/metaRecordAjax/listWithIdentity.json",
+        __spreadProps(__spreadValues({}, params), {
+          page: params.page || 1,
+          size: params.size || 100
+        }),
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.listMetaRecordWithIdentity = listMetaRecordWithIdentity;
+  function getMetaRecordWithIdentity(params) {
+    return __async$1(this, null, function* () {
+      return slsEasyFetch.get("/console/metaRecordAjax/getWithIdentity.json", params);
+    });
+  }
+  metaService2.getMetaRecordWithIdentity = getMetaRecordWithIdentity;
+  function updataMetaRecordWithIdentity(_0) {
+    return __async$1(this, arguments, function* ({ name, record }, forbidAlert = false) {
+      const recordObj = __spreadProps(__spreadValues({}, record), {
+        value: JSON.stringify(record.value)
+      });
+      return slsEasyFetch.post(
+        "/console/metaRecordAjax/updateWithIdentity.json",
+        {
+          name,
+          record: JSON.stringify(recordObj)
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.updataMetaRecordWithIdentity = updataMetaRecordWithIdentity;
+  function deleteRecords() {
+    return __async$1(this, arguments, function* (config = {
+      name: "",
+      recordIds: ""
+      // 1,2
+    }, forbidAlert = false) {
+      return slsEasyFetch.post("/console/metaRecordAjax/delete.json", config, { forbidAlert });
+    });
+  }
+  metaService2.deleteRecords = deleteRecords;
+  function deleteRecordsWithIdentity() {
+    return __async$1(this, arguments, function* (config = {
+      name: "",
+      recordIds: ""
+      // 1,2
+    }, forbidAlert = false) {
+      return slsEasyFetch.post("/console/metaRecordAjax/deleteWithIdentity.json", config, {
+        forbidAlert
+      });
+    });
+  }
+  metaService2.deleteRecordsWithIdentity = deleteRecordsWithIdentity;
+  function deleteResource(params) {
+    return __async$1(this, null, function* () {
+      return slsEasyFetch.post("/console/metaResourceAjax/delete.json", params);
+    });
+  }
+  metaService2.deleteResource = deleteResource;
+  function createSomeMetaRecordsWithIdentity(_0) {
+    return __async$1(this, arguments, function* ({ name, records }, forbidAlert = false) {
+      return slsEasyFetch.post(
+        "/console/metaRecordAjax/batchUpsertWithIdentity.json",
+        {
+          name,
+          records: JSON.stringify(records)
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.createSomeMetaRecordsWithIdentity = createSomeMetaRecordsWithIdentity;
+  function createSomeMetaRecords(_0) {
+    return __async$1(this, arguments, function* ({ name, records }, forbidAlert = false) {
+      return slsEasyFetch.post(
+        "/console/metaRecordAjax/batchUpsert.json",
+        {
+          name,
+          records: JSON.stringify(records)
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.createSomeMetaRecords = createSomeMetaRecords;
+  function getNewDashboardList(_0) {
+    return __async$1(this, arguments, function* ({ name, jsonPath, jsonPathValue, page, size }, forbidAlert = false) {
+      return slsEasyFetch.post(
+        `/console/metaRecordAjax/list.json`,
+        {
+          name,
+          jsonPath,
+          jsonPathValue,
+          page,
+          size
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.getNewDashboardList = getNewDashboardList;
+  function getNewDashboardListWithIdentity(_0) {
+    return __async$1(this, arguments, function* ({ name, jsonPath, jsonPathValue, page, size }, forbidAlert = false) {
+      return slsEasyFetch.post(
+        `/console/metaRecordAjax/listWithIdentity.json`,
+        {
+          name,
+          jsonPath,
+          jsonPathValue,
+          page,
+          size
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.getNewDashboardListWithIdentity = getNewDashboardListWithIdentity;
+  function deleteVersionRecords(_0) {
+    return __async$1(this, arguments, function* ({ name, recordIds }, forbidAlert = false) {
+      return slsEasyFetch.post(
+        "/console/metaRecordAjax/delete.json",
+        {
+          name,
+          recordIds
+        },
+        { forbidAlert }
+      );
+    });
+  }
+  metaService2.deleteVersionRecords = deleteVersionRecords;
+  metaService2.ckeckPermissionForList = (resourceName) => __async$1(void 0, null, function* () {
+    const res = yield slsEasyFetch.get(
+      "/console/metaRecordAjax/checkList.json",
+      {
+        name: resourceName
+      },
+      { forbidAlert: true }
+    );
+    if (!res.data) {
+      return false;
+    }
+    return true;
+  });
+})(metaService || (metaService = {}));
+
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -136,19 +1030,45 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-const easyFetch = new BaseFetch();
-easyFetch.defaults.postDefaultInit.headers["Content-Type"] = "application/x-www-form-urlencoded";
-easyFetch.defaults.postDefaultInit.headers["Accept"] = "application/json";
-easyFetch.defaults.afterResponse = (response) => __async(void 0, null, function* () {
-  if (response.status >= 200 && response.status < 300) {
-    const data = yield response.json();
-    return __spreadProps(__spreadValues({}, data != null ? data : {}), {
-      response
+var workSpaceService;
+((workSpaceService2) => {
+  function getWorkspaceRecord(params) {
+    return __async(this, null, function* () {
+      return slsEasyFetch.get("/console/workspace/list_app.json", params);
     });
-  } else {
-    throw new Error(response.statusText);
   }
-});
+  workSpaceService2.getWorkspaceRecord = getWorkspaceRecord;
+  function getWorkspacelist(params) {
+    return __async(this, null, function* () {
+      return slsEasyFetch.get("/console/workspace/list.json", params);
+    });
+  }
+  workSpaceService2.getWorkspacelist = getWorkspacelist;
+  function getWorkspaceInfor(params) {
+    return __async(this, null, function* () {
+      return slsEasyFetch.get("/console/workspace/get.json", params);
+    });
+  }
+  workSpaceService2.getWorkspaceInfor = getWorkspaceInfor;
+  function createInstance(params) {
+    return __async(this, null, function* () {
+      return slsEasyFetch.post("/observability/createInstance.json", params);
+    });
+  }
+  workSpaceService2.createInstance = createInstance;
+  function updataAppInstance(params) {
+    return __async(this, null, function* () {
+      return slsEasyFetch.post("/console/workspace/update_app.json", params);
+    });
+  }
+  workSpaceService2.updataAppInstance = updataAppInstance;
+  function getWorkspaceForITOM(params) {
+    return __async(this, null, function* () {
+      return slsEasyFetch.get("/console/workspace/getWorkspaceForITOM.json", params);
+    });
+  }
+  workSpaceService2.getWorkspaceForITOM = getWorkspaceForITOM;
+})(workSpaceService || (workSpaceService = {}));
 
-export { easyFetch };
+export { commonEasyFetch, metaService, obsEasyFetch, showAlertDialog, showAlertDialogWhenNeedLogin, slsEasyFetch, workSpaceService };
 //# sourceMappingURL=api.es.js.map

package/package.json

@@ -8,8 +8,13 @@
   "keywords": [],
   "dependencies": {
     "urijs": "^1.19.1",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.21",
+    "@alicloud/console-base-error-prompt-proxy": "^1.9.12",
+    "@aliyun-obv/i18n": "0.0.43",
+    "@aliyun-obv/utils": "0.0.43",
+    "@alifd/next": "^1.27.11",
+    "styled-components": "^5.2.0"
   },
   "devDependencies": {},
-  "version": "0.0.41"
+  "version": "0.0.43"
 }