@opentinyvue/vue-renderless 3.21.0

package/locales/index.js

@@ -0,0 +1,82 @@
+import "../chunk-G2ADBYYC.js";
+import { xss } from "@opentiny/utils";
+const getLocales = ({ api, service, state }) => () => {
+  Promise.all([service.getLocale(), service.getCurrentLocale()]).then(([locales, current]) => {
+    state.locales = locales || ["zhCN"];
+    state.current = (Array.isArray(current) ? current[0] : current) || "zhCN";
+    api.setText(current);
+  });
+};
+const setText = (state) => () => {
+  const { current, locales } = state;
+  const len = locales.length;
+  state.text = len === 2 ? locales.indexOf(current) === 0 ? locales[1] : locales[0] : current;
+};
+const switchLanguage = ({ api, state, service }) => (lang) => {
+  const { locales, current } = state;
+  const hasMultiLocale = state.locales.length === 2;
+  state.current = hasMultiLocale ? state.current = locales.indexOf(current) === 0 ? locales[1] : locales[0] : lang;
+  api.setText();
+};
+const changeLocale = ({ props, service, vnode }) => (value, oldValue) => {
+  if (!value || !oldValue) {
+    return;
+  }
+  const { local, changeLang } = props;
+  if (typeof changeLang === "function") {
+    changeLang(value);
+    return;
+  }
+  if (local) {
+    value.slice(0, 2) === "zh" ? vnode.use(vnode.zhCN) : vnode.use(vnode.enUS);
+    return;
+  }
+  const { content = "" } = service.customized;
+  service.getCustomized().then((data) => {
+    data = data || [];
+    const setting = data.filter((item) => item.settingKey === vnode.constants.GLOBAL)[0] || {};
+    service.getChangeLocaleUrl(value).then((url) => {
+      try {
+        const settingContent = JSON.parse(setting[content]);
+        settingContent.lang = value;
+        settingContent.common.lang = value;
+        setting[content] = JSON.stringify(settingContent);
+        service.pushCustomized(setting).then(() => {
+          window.location.href = xss.filterUrl(url);
+        });
+      } catch (error) {
+        window.location.href = xss.filterUrl(url);
+      }
+    });
+  });
+};
+const initService = ({ props, service }) => {
+  const { common = {}, utils = {}, setting = {}, fetchSsoUpdate, pushCustomized } = service || {};
+  const { options = {} } = setting;
+  const noopFnCreator = (propName) => () => {
+    if (propName) {
+      return Promise.reject(
+        new Error(`[TINY Error][Locale] Prop ${propName} is mandatory when the framework service is not used`)
+      );
+    } else {
+      return Promise.resolve(null);
+    }
+  };
+  return {
+    getLocale: props.getLocale || common.getLocale || noopFnCreator("getLocale"),
+    getCurrentLocale: props.getCurrentLocale || common.getCurrentLocale || noopFnCreator("getCurrentLocale"),
+    getChangeLocaleUrl: props.getChangeLocaleUrl || common.getChangeLocaleUrl || noopFnCreator("getChangeLocaleUrl"),
+    fetchSsoUpdate: props.fetchSsoUpdate || fetchSsoUpdate || noopFnCreator("fetchSsoUpdate"),
+    getDomain: props.getDomain || utils.getDomain || noopFnCreator("getDomain"),
+    getCustomized: common.getCustomized || noopFnCreator(),
+    pushCustomized: pushCustomized || noopFnCreator(),
+    customized: options.Customized || {}
+  };
+};
+export {
+  changeLocale,
+  getLocales,
+  initService,
+  setText,
+  switchLanguage
+};

package/locales/vue.js

@@ -0,0 +1,28 @@
+import "../chunk-G2ADBYYC.js";
+import { getLocales, setText, switchLanguage, initService, changeLocale } from "./index";
+const api = ["state", "switchLanguage", "t", "changeLocale"];
+const renderless = (props, { reactive, watch }, { t, service }, vnode) => {
+  const api2 = {};
+  const $service = initService({ props, service });
+  const state = reactive({
+    current: "",
+    locales: [],
+    visible: false,
+    text: ""
+  });
+  Object.assign(api2, {
+    t,
+    state,
+    setText: setText(state),
+    changeLocale: changeLocale({ props, service: $service, vnode }),
+    switchLanguage: switchLanguage({ api: api2, service: $service, state }),
+    getLocales: getLocales({ api: api2, service: $service, state })
+  });
+  api2.getLocales();
+  watch(() => state.current, api2.changeLocale, { immediate: true });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/logon-user/index.js

@@ -0,0 +1,20 @@
+import "../chunk-G2ADBYYC.js";
+const init = ({ service, state }) => () => {
+  const { getUserInfo } = service;
+  getUserInfo().then((user) => {
+    state.userName = user.userCN;
+  });
+};
+const initService = ({ props, service }) => {
+  const { base = {} } = service || {};
+  const getUserInfoNoop = () => Promise.reject(
+    new Error("[TINY Error][LogonUser] Prop getUserInfo is mandatory when the framework service is not used")
+  );
+  return {
+    getUserInfo: props.getUserInfo || base.getUserInfo || getUserInfoNoop
+  };
+};
+export {
+  init,
+  initService
+};

package/logon-user/vue.js

@@ -0,0 +1,19 @@
+import "../chunk-G2ADBYYC.js";
+import { init, initService } from "./index";
+const api = ["state"];
+const renderless = (props, { reactive }, { service }) => {
+  const $service = initService({ props, service });
+  const state = reactive({
+    userName: ""
+  });
+  const api2 = {
+    state,
+    init: init({ service: $service, state })
+  };
+  api2.init();
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/logout/index.js

@@ -0,0 +1,84 @@
+import "../chunk-G2ADBYYC.js";
+import { xss } from "@opentiny/utils";
+const logout = ({ service, state, props }) => () => {
+  let { isMock, isLocal, redirectUrl = "", getLogoutUrl, showLogin } = service;
+  if (typeof props.beforeLogout === "function" && !state.logout) {
+    if (props.beforeLogout(redirectUrl) === false) {
+      return;
+    }
+  }
+  if (state.logout) {
+    showLogin();
+    return;
+  }
+  const location = window.location;
+  if (redirectUrl) {
+    const isFullPath = redirectUrl.includes("//");
+    if (!isFullPath) {
+      redirectUrl.indexOf("#/") === 0 || (redirectUrl = "#/" + redirectUrl);
+      redirectUrl = location.protocol + "//" + location.host + location.pathname + redirectUrl;
+    }
+  } else {
+    redirectUrl = location.href;
+  }
+  redirectUrl = xss.filterUrl(redirectUrl);
+  if (!isMock || !isLocal) {
+    getLogoutUrl(redirectUrl).then((url) => {
+      let temp = decodeURIComponent(url);
+      if (/%[a-fA-F0-9]{2}/.test(temp)) {
+        temp = decodeURIComponent(temp);
+      }
+      location.href = xss.filterUrl(temp);
+    });
+  } else {
+    location.href = xss.filterUrl(redirectUrl);
+  }
+  state.logout = true;
+};
+const initService = ({ props, service }) => {
+  const noopFnCreator = (propName) => () => {
+    if (propName) {
+      return Promise.reject(
+        new Error(`[TINY Error][Logout] Prop ${propName} is mandatory when the framework service is not used`)
+      );
+    } else {
+      return Promise.reject(
+        new Error("[TINY Error][Logout] Prop service is mandatory when the framework service is not used")
+      );
+    }
+  };
+  const { base = {}, common = {}, setting = {}, network = {}, ajax = {}, message = {} } = service || {};
+  const { options = {}, services = {}, redirectUrl = "", local = false } = setting;
+  const { isMock = () => false } = network;
+  const { getUserInfoSync = noopFnCreator() } = base;
+  const { config = noopFnCreator() } = ajax;
+  const { subscribe = noopFnCreator(), publish = noopFnCreator() } = message;
+  return {
+    getLogoutUrl: props.getLogoutUrl || common.getLogoutUrl || noopFnCreator("getLogoutUrl"),
+    redirectUrl: props.redirectUrl || redirectUrl,
+    isLocal: props.isLocal || local,
+    network: props.network || network,
+    isMock: props.isMock || isMock(),
+    isGuestUser: props.isGuestUser || (() => getUserInfoSync().userAccount === props.guestRole),
+    showLogin: props.showLogin || (() => {
+      window.document.domain = options.Domain;
+      const gateway = config();
+      subscribe({
+        topic: "tiny.ui.closeLoginDialog",
+        callback() {
+          window.location.reload();
+        }
+      });
+      publish({
+        topic: "tiny.ui.displayLoginDialog",
+        data: {
+          url: gateway.getRequestUrl(services.Framework.RebuildSession)
+        }
+      });
+    })
+  };
+};
+export {
+  initService,
+  logout
+};

package/logout/vue.js

@@ -0,0 +1,18 @@
+import "../chunk-G2ADBYYC.js";
+import { logout, initService } from "./index";
+const api = ["state", "logout"];
+const renderless = (props, { reactive }, { service }) => {
+  const $service = initService({ props, service });
+  const state = reactive({
+    logout: $service.isGuestUser()
+  });
+  const api2 = {
+    state,
+    logout: logout({ service: $service, state, props })
+  };
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/mask/index.js

@@ -0,0 +1,13 @@
+import "../chunk-G2ADBYYC.js";
+const handleTouch = ({ props, emit }) => (event) => {
+  if (props.cancelTouch) {
+    event.preventDefault();
+    event.stopPropagation();
+  } else {
+    emit("update:visible", false);
+  }
+  emit("click", props.visible);
+};
+export {
+  handleTouch
+};

package/mask/vue.js

@@ -0,0 +1,18 @@
+import "../chunk-G2ADBYYC.js";
+import { handleTouch } from "./index";
+const api = ["state", "handleTouch"];
+const renderless = (props, { reactive, computed }, { emit }) => {
+  const api2 = {};
+  const state = reactive({
+    calcStyle: computed(() => ({ zIndex: props.zIndex }))
+  });
+  Object.assign(api2, {
+    state,
+    handleTouch: handleTouch({ props, emit })
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/menu/index.js

@@ -0,0 +1,140 @@
+import "../chunk-G2ADBYYC.js";
+import { xss } from "@opentiny/utils";
+import { deepClone } from "../picker-column";
+const filterInput = ({ state }) => (val) => {
+  state.filterValue = val;
+};
+const computeData = ({ props, vm }) => () => filterNodeUrl(props.data || [], vm);
+const filterNodeUrl = (data, vm) => {
+  data.forEach((node) => {
+    node.url = xss.filterUrl(node.url);
+    vm.$set(node, "isCurrent", false);
+    if (node.children) {
+      filterNodeUrl(node.children, vm);
+    }
+  });
+  return data;
+};
+const setIsCurrent = ({ props, vm, state }) => (data, node) => {
+  if (props.onlyCheckChildren && node.children)
+    return;
+  const nodeId = node.id;
+  if (state.filterValue && state.filterData.length) {
+    getIsCurrent(vm, { children: state.filterData }, nodeId);
+    state.activedKeys = nodeId;
+  } else {
+    getIsCurrent(vm, { children: data }, nodeId);
+    state.filterCheckedId = null;
+  }
+  state.activedNodeId = nodeId;
+  if (props.onlyCheckChildren) {
+    state.currentPaths = findPaths(data, nodeId);
+  }
+};
+const getIsCurrent = (vm, node, nodeId) => {
+  if (!node.children)
+    return;
+  for (let i = 0; i < node.children.length; i++) {
+    const isCurrentNode = node.children[i].id === nodeId;
+    vm.$set(node.children[i], "isCurrent", isCurrentNode);
+    getIsCurrent(vm, node.children[i], nodeId);
+  }
+};
+const filterNodes = ({ state, api, nextTick }) => (label) => {
+  if (label !== "") {
+    state.filterData = filterTree(deepClone(state.data), label);
+  } else {
+    state.filterData = [];
+    if (state.activedKeys) {
+      api.getActivedKeysPath(state.activedKeys);
+      nextTick(() => {
+        api.setIsCurrent(state.data, { id: state.activedKeys });
+      });
+    }
+  }
+};
+const getExpandedKeysPath = ({ state }) => (keys) => {
+  const paths = [];
+  const len = keys.length;
+  for (let i = 0; i < len; i++) {
+    if (!paths.includes(keys[i])) {
+      paths.push(...findPaths(state.data, keys[i]));
+    }
+  }
+  state.expandedKeysPath = paths;
+};
+const getActivedKeysPath = ({ state }) => (key) => {
+  if (key !== null && key !== void 0) {
+    state.activedKeysPath = findPaths(state.data, key) || [];
+  }
+};
+const setNodeHidden = ({ props, vm, state }) => (nodeId) => {
+  if (state.filterValue && state.filterData.length) {
+    hiddenNode(vm, state.filterData, nodeId);
+  }
+  if (props.expandAll && !state.filterValue) {
+    hiddenNode(vm, state.data, nodeId);
+  }
+};
+const setAllNodeVisible = ({ vm, state }) => () => {
+  setNodeVisible(vm, state.data);
+};
+const setNodeVisible = (vm, nodes) => {
+  if (!nodes)
+    return;
+  for (let i = 0; i < nodes.length; i++) {
+    vm.$set(nodes[i], "visible", true);
+    if (nodes[i].children) {
+      setNodeVisible(vm, nodes[i].children);
+    }
+  }
+};
+const existChildren = (node) => node.children && node.children.length;
+const filterTree = (nodes, label) => {
+  const result = [];
+  for (const node of nodes) {
+    if (existChildren(node)) {
+      node.children = filterTree(node.children, label);
+    }
+    if (node.label.includes(label) || existChildren(node)) {
+      node.visible = true;
+      result.push(node);
+    }
+  }
+  return result;
+};
+const hiddenNode = (vm, nodes, nodeId) => {
+  if (!nodes)
+    return;
+  for (let i = 0; i < nodes.length; i++) {
+    if (nodes[i].id === nodeId) {
+      vm.$set(nodes[i], "visible", false);
+    }
+    if (nodes[i].children) {
+      hiddenNode(vm, nodes[i].children, nodeId);
+    }
+  }
+};
+const findPaths = (nodes, nodeId) => {
+  for (let i in nodes) {
+    if (nodes[i].id === nodeId) {
+      return [nodes[i].id];
+    }
+    if (nodes[i].children) {
+      let res = findPaths(nodes[i].children, nodeId);
+      if (res) {
+        return res.concat(nodes[i].id);
+      }
+    }
+  }
+};
+export {
+  computeData,
+  filterInput,
+  filterNodes,
+  getActivedKeysPath,
+  getExpandedKeysPath,
+  setAllNodeVisible,
+  setIsCurrent,
+  setNodeHidden
+};

package/menu/vue.js

@@ -0,0 +1,99 @@
+import "../chunk-G2ADBYYC.js";
+import {
+  setIsCurrent,
+  filterNodes,
+  getExpandedKeysPath,
+  getActivedKeysPath,
+  setNodeHidden,
+  setAllNodeVisible,
+  filterInput,
+  computeData
+} from "./index";
+import debounce from "../common/deps/debounce";
+const api = ["state", "setIsCurrent", "filterNodes", "filterInput"];
+const initState = ({ reactive, computed, props, api: api2 }) => {
+  const state = reactive({
+    isEmpty: computed(() => props.data.length !== 0 && state.filterValue && state.filterData.length === 0),
+    activedNodeId: null,
+    filterValue: "",
+    currentPaths: [],
+    filterData: [],
+    data: computed(() => api2.computeData())
+  });
+  return state;
+};
+const renderless = (props, { reactive, watch, onMounted, computed, onUnmounted }, { vm, emit, nextTick }) => {
+  const api2 = {};
+  const state = initState({ reactive, computed, props, api: api2 });
+  Object.assign(api2, {
+    state,
+    setIsCurrent: setIsCurrent({ props, vm, state, emit, nextTick }),
+    filterNodes: debounce(100, filterNodes({ vm, state, api: api2, nextTick })),
+    setNodeHidden: setNodeHidden({ props, vm, state }),
+    getActivedKeysPath: getActivedKeysPath({ state }),
+    getExpandedKeysPath: getExpandedKeysPath({ state }),
+    setAllNodeVisible: setAllNodeVisible({ vm, state }),
+    filterInput: filterInput({ state }),
+    computeData: computeData({ props, vm })
+  });
+  watch(
+    () => props.expandAll,
+    () => {
+      props.expandAll && api2.setAllNodeVisible();
+    },
+    { immediate: true }
+  );
+  watch(
+    () => state.filterValue,
+    () => {
+      api2.filterNodes(state.filterValue);
+    }
+  );
+  watch(
+    () => props.expandedKeys,
+    () => {
+      if (props.expandedKeys && props.expandedKeys.length) {
+        api2.getExpandedKeysPath(props.expandedKeys);
+      }
+    },
+    { deep: true, immediate: true }
+  );
+  watch(
+    () => props.activedKeys,
+    (val) => {
+      if (val || val === 0) {
+        state.activedKeys = props.activedKeys;
+        api2.getActivedKeysPath(props.activedKeys);
+        api2.setIsCurrent(props.data, { id: props.activedKeys });
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => props.data,
+    (val) => {
+      nextTick(() => {
+        api2.setIsCurrent(val, { id: props.activedKeys });
+      });
+    }
+  );
+  onMounted(() => {
+    vm.$on("node-clicked", (param) => {
+      api2.setNodeHidden(param.id);
+      vm.$emit("node-click", param);
+    });
+    vm.$on("node-changed", (param) => {
+      vm.$emit("current-change", param);
+      api2.setIsCurrent(state.data, param);
+    });
+  });
+  onUnmounted(() => {
+    vm.$off("node-clicked");
+    vm.$off("node-changed");
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/menu-node/index.js

@@ -0,0 +1,12 @@
+import "../chunk-G2ADBYYC.js";
+const handelNodeClick = ({ state, dispatch }) => (node) => {
+  dispatch("Menu", "node-clicked", node);
+  if (node.disabled)
+    return;
+  state.showNodes = !state.showNodes;
+  state.activeNodeId = node.id;
+  dispatch("Menu", "node-changed", node);
+};
+export {
+  handelNodeClick
+};

package/menu-node/vue.js

@@ -0,0 +1,42 @@
+import "../chunk-G2ADBYYC.js";
+import { handelNodeClick } from "./index";
+const api = ["state", "handelNodeClick"];
+const renderless = (props, { reactive, watch, computed }, { dispatch, nextTick }) => {
+  const api2 = {};
+  const state = reactive({
+    renderNodes: false,
+    showNodes: false,
+    activeNodeId: null,
+    allExpandedKeysPath: computed(() => [...props.expandedKeysPath, ...props.activedKeysPath])
+  });
+  Object.assign(api2, {
+    state,
+    handelNodeClick: handelNodeClick({ state, dispatch })
+  });
+  watch(
+    () => props.activedKeys,
+    () => {
+      if (props.activedKeys && props.nodes.id === props.activedKeys && state.activeNodeId !== props.activedKeys) {
+        nextTick(() => {
+          state.activeNodeId = props.activedKeys;
+          dispatch("Menu", "node-changed", { id: props.activedKeys });
+        });
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => state.allExpandedKeysPath,
+    () => {
+      if (state.allExpandedKeysPath.length) {
+        state.showNodes = state.allExpandedKeysPath.includes(props.nodes.id);
+      }
+    },
+    { deep: true, immediate: true }
+  );
+  return api2;
+};
+export {
+  api,
+  renderless
+};