@sdata-plugin-adapter/utils 0.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { AdapterProps } from '@sdata-plugin-adapter/types';
+
+/**
+ * 泛型定义 :
+ *  L: label 标签
+ *  V: value 值
+ *  C: code 代码
+ *  test: build update version
+ */
+interface EnumItem {
+    0: string;
+    1: string | number;
+    2: string;
+    length: 3;
+}
+interface LabelsMap {
+    [key: string | number]: string;
+}
+interface CodesMap {
+    [code: string]: string | number;
+}
+interface DescMap {
+    [code: string]: string;
+}
+interface GetCodesFromValueMap {
+    [value: string | number]: string;
+}
+interface OptionItem {
+    [key: string]: string | number;
+}
+declare class Enum {
+    originalEnum: EnumItem[];
+    codes: CodesMap;
+    desc: DescMap;
+    labels: LabelsMap;
+    getCodesFromValue: GetCodesFromValueMap;
+    get length(): number | undefined;
+    get arrLabels(): (string | undefined)[];
+    get values(): (string | number | undefined)[];
+    get keys(): (string | undefined)[];
+    constructor(parameters: EnumItem[]);
+    options(label?: string, value?: string, key?: string): OptionItem[];
+}
+
+type LoadScriptPromise = Promise<void>;
+declare function loadScript(path: string, loadFlag: string, mountedName: string, maxIntervalCount?: number): LoadScriptPromise;
+declare function loadStyle(path: string, loadFlag: string): void;
+
+declare const LANG_EN = "en-us";
+declare const LANG_ZH = "zh-cn";
+declare const lang_type: string;
+declare const setLocalePrefix: (prefix: string) => void;
+declare const setLang: (path: string) => Promise<void>;
+declare const intlGetKey: (key: string, ...rest: any[]) => any;
+
+declare const generateUUID: () => string;
+declare const setDomAttributes: (dom: Element, props: AdapterProps, adapter: (props: AdapterProps) => AdapterProps) => Promise<void>;
+
+export { Enum, LANG_EN, LANG_ZH, generateUUID, intlGetKey, lang_type, loadScript, loadStyle, setDomAttributes, setLang, setLocalePrefix };

package/dist/index.js

@@ -0,0 +1,223 @@
+// index.ts
+import configJson3 from "configJson";
+
+// export/enum.ts
+var Enum = class {
+  get length() {
+    return this.originalEnum?.length;
+  }
+  get arrLabels() {
+    return this.originalEnum?.map?.((item) => item[0]) ?? [];
+  }
+  get values() {
+    return this.originalEnum?.map?.((item) => item[1]) ?? [];
+  }
+  get keys() {
+    return this.originalEnum?.map?.((item) => item[2]) ?? [];
+  }
+  constructor(parameters) {
+    this.originalEnum = parameters;
+    let labels = {};
+    let codes = {};
+    let desc = {};
+    let getCodesFromValue = {};
+    parameters.forEach((item) => {
+      let label = item[0];
+      let value = item[1];
+      let code = item[2];
+      codes[code] = value;
+      desc[code] = label;
+      labels[value] = label;
+      getCodesFromValue[value] = code;
+    });
+    this.labels = labels;
+    this.desc = desc;
+    this.codes = codes;
+    this.getCodesFromValue = getCodesFromValue;
+  }
+  options(label = "label", value = "value", key = "key") {
+    return this.originalEnum?.map?.((item) => {
+      let outPut = {};
+      outPut[label] = item[0];
+      outPut[value] = item[1];
+      outPut[key] = item[2];
+      return outPut;
+    }) ?? [];
+  }
+};
+
+// export/loadSource.ts
+import configJson from "configJson";
+var isEnvProduction = !import.meta.env.DEV;
+var host = configJson["online-development-mode"]?.host ?? "http://localhost";
+var port = configJson["online-development-mode"]?.port ?? 3e3;
+var currentScriptPath = getRuningScriptPath();
+var productionPrefix = currentScriptPath.split("/").slice(0, -2).join("/") + "/assets/";
+var prefix = isEnvProduction ? productionPrefix : `${host}:${port}/`;
+function resolveFun(resolve, maxIntervalCount, mountedName) {
+  let count = 0;
+  const mountInterval = setInterval(() => {
+    if (count >= maxIntervalCount || (mountedName ? window[mountedName] : true)) {
+      clearInterval(mountInterval);
+      resolve();
+    }
+    count++;
+  }, 20);
+}
+function loadScript(path, loadFlag, mountedName, maxIntervalCount = 20) {
+  if (window?.[mountedName]) {
+    return new Promise((resolve) => {
+      resolve();
+    });
+  } else if (window?.[loadFlag]) {
+    return window[loadFlag];
+  }
+  const mountedFn = new Promise((resolve) => {
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    if (path.indexOf("http") > -1 || path.startsWith("//")) {
+      script.src = path;
+    } else {
+      script.src = `${prefix}${path}`;
+    }
+    document.head.appendChild(script);
+    if (script?.readyState) {
+      script.onreadystatechange = function() {
+        if (script.readyState == "loaded" || script.readyState == "complete") {
+          script.onreadystatechange = null;
+          resolveFun(resolve, maxIntervalCount, mountedName);
+        }
+      };
+    } else {
+      script.onload = function() {
+        resolveFun(resolve, maxIntervalCount, mountedName);
+      };
+    }
+  });
+  return window[loadFlag] = mountedFn;
+}
+function getRuningScriptPath() {
+  const currentScript = document.currentScript;
+  if (currentScript && currentScript.src !== "") {
+    return currentScript.src;
+  }
+  const match = new Error().stack?.match(/(https?:[^:]*).*\.js/);
+  return match?.[0] ?? "";
+}
+function loadStyle(path, loadFlag) {
+  if (window[loadFlag]) {
+    return;
+  }
+  const style = document.createElement("link");
+  if (path.indexOf("http") > -1 || path.startsWith("//")) {
+    style.href = path;
+  } else {
+    style.href = `${prefix}${path}`;
+  }
+  style.type = "text/css";
+  style.rel = "stylesheet";
+  document.head.appendChild(style);
+  window[loadFlag] = style;
+}
+
+// export/locales.ts
+import configJson2 from "configJson";
+var { isValidElement } = window.React ?? {};
+var isEnvProduction2 = !import.meta.env.DEV;
+var host2 = configJson2["online-development-mode"]?.host ?? "http://localhost";
+var port2 = configJson2["online-development-mode"]?.port ?? 3e3;
+var currentScriptPath2 = getRuningScriptPath();
+var productionPrefix2 = currentScriptPath2.split("/").slice(0, -2).join("/") + "/assets/";
+var prefix2 = isEnvProduction2 ? productionPrefix2 : `${host2}:${port2}/`;
+var LANG_EN = "en-us";
+var LANG_ZH = "zh-cn";
+var localStorageLocaleKey = "lang_type";
+var getLanguage = () => {
+  const language = window?.appSdk?.intl?.determineLocale?.({
+    localStorageLocaleKey
+  });
+  if (language?.toLowerCase()?.startsWith?.("zh")) {
+    return LANG_ZH;
+  } else {
+    return LANG_EN;
+  }
+};
+var lang_type = getLanguage();
+var locale_prefix = `custom_plugin_locales_${configJson2.id}`;
+var setLocalePrefix = (prefix3) => {
+  locale_prefix = prefix3;
+};
+var loadJSON = (path) => {
+  return new Promise((resolve, reject) => {
+    const url = path.startsWith("http") ? path : `${prefix2}${path}`;
+    fetch(url).then((res) => res.json()).then((data) => {
+      resolve(data);
+    }).catch(() => reject("\u83B7\u53D6\u56FD\u9645\u5316JSON\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u6587\u4EF6\u8DEF\u5F84\u662F\u5426\u6B63\u786E\uFF01"));
+  });
+};
+var setLang = async (path) => {
+  try {
+    const data = await loadJSON(path);
+    const locales = {
+      [lang_type]: () => Promise.resolve({ default: data })
+    };
+    await window.appSdk.loadIntl(locales, locale_prefix);
+  } catch (error) {
+    window.console.error(error);
+  }
+};
+var intlGetKey = (key, ...rest) => {
+  const regex = new RegExp("(.[\u4E00-\u9FA5]+)|([\u4E00-\u9FA5]+.)", "g");
+  if (isValidElement?.(key) || regex.test(key) || typeof key === "number" || typeof key === "object")
+    return key;
+  if (!key) return;
+  const res = window.appSdk.intl.get(
+    `${locale_prefix}.${key}` || "common.empty",
+    ...rest
+  );
+  return typeof res === "object" ? key : res.d(key);
+};
+
+// index.ts
+var isEnvProd = import.meta.env.PROD;
+var generateUUID = () => {
+  let d = (/* @__PURE__ */ new Date()).getTime();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    let r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    return (c == "x" ? r : r & 3 | 8).toString(16);
+  });
+};
+var setDomAttributes = async (dom, props, adapter) => {
+  const pluginType = configJson3.type;
+  const adapterProps = adapter(props);
+  let {
+    customConfig = {},
+    customOptions,
+    type = ""
+  } = adapterProps;
+  if (pluginType === "bigscreen" || pluginType === "analyzer") {
+    customConfig = customOptions;
+  }
+  const requirementNum = configJson3["requirement-number"] ? `${configJson3["requirement-number"]}-` : "";
+  const domSymbol = customConfig?.id ? `${pluginType}-${type}-secondary-${requirementNum}${customConfig.id}` : `${pluginType}-${type}-secondary-${requirementNum}${generateUUID()}`;
+  let className = dom.className;
+  className = className ? `${className} ${domSymbol}` : domSymbol;
+  dom.setAttribute("class", className);
+  if (isEnvProd && type != "designConfiguration") {
+    console.info(`\u9700\u6C42\u7F16\u53F7:${configJson3["requirement-number"]}`, dom);
+  }
+};
+export {
+  Enum,
+  LANG_EN,
+  LANG_ZH,
+  generateUUID,
+  intlGetKey,
+  lang_type,
+  loadScript,
+  loadStyle,
+  setDomAttributes,
+  setLang,
+  setLocalePrefix
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@sdata-plugin-adapter/utils",
+  "version": "0.0.0-alpha.1",
+  "description": "toolset of smdata plugin",
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "peerDependencies": {
+    "@sdata-plugin-adapter/types": "0.0.0-alpha.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsup"
+  }
+}