@vef-framework/core 1.0.122 → 1.0.124

package/esm/api/query-client.js

@@ -0,0 +1,31 @@
+"use strict";
+import { QueryClient } from '@tanstack/react-query';
+
+"use strict";
+function createQueryClient(options) {
+  const staleTime = options?.staleTime ?? Infinity;
+  const gcTime = options?.gcTime ?? 10 * 60 * 1e3;
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        networkMode: "always",
+        staleTime,
+        gcTime,
+        retry: false,
+        structuralSharing: true,
+        throwOnError: false,
+        refetchOnMount: false,
+        refetchOnReconnect: true,
+        refetchOnWindowFocus: true
+      },
+      mutations: {
+        networkMode: "always",
+        gcTime: staleTime,
+        retry: false,
+        throwOnError: false
+      }
+    }
+  });
+}
+
+export { createQueryClient };

package/esm/api/request-client.js

@@ -0,0 +1,250 @@
+"use strict";
+import { isNullish, showInfoMessage, showWarningMessage, VefError, isString, showErrorMessage, isFunction } from '@vef-framework/shared';
+import axios, { CanceledError } from 'axios';
+import qs from 'qs';
+
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _axiosInstance;
+const pathParamRegex = /\{\w+\}/;
+class RequestClient {
+  constructor(options) {
+    this.options = options;
+    /**
+     * The axios instance.
+     */
+    __privateAdd(this, _axiosInstance);
+    const {
+      baseUrl,
+      timeout,
+      getAccessToken,
+      successCode = 0,
+      unauthorizedCode = 1e3,
+      accessDeniedCode = 1002,
+      tokenExpiredCode = 1001,
+      onUnauthorized,
+      onAccessDenied
+    } = options;
+    __privateSet(this, _axiosInstance, axios.create({
+      baseURL: baseUrl,
+      timeout: timeout ?? 1e3 * 30,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      paramsSerializer: (params) => qs.stringify(
+        params,
+        {
+          arrayFormat: "repeat",
+          skipNulls: true,
+          charset: "utf-8"
+        }
+      ),
+      responseType: "json",
+      validateStatus: () => true
+    }));
+    __privateGet(this, _axiosInstance).interceptors.request.use((config) => {
+      const token = getAccessToken?.();
+      if (token) {
+        config.headers.Authorization = `Bearer ${token}`;
+      }
+      const { url } = config;
+      if (url && pathParamRegex.test(url)) {
+        config.url = url.replace(pathParamRegex, (_, key) => {
+          const value = config.params?.[key];
+          if (isNullish(value)) {
+            throw new Error(`Path parameter ${key} is nil`);
+          }
+          return value;
+        });
+      }
+      return config;
+    });
+    __privateGet(this, _axiosInstance).interceptors.response.use(
+      async (response) => {
+        const { code, message } = response.data;
+        if (code === successCode) {
+          return response;
+        } else if (code === unauthorizedCode) {
+          await onUnauthorized?.();
+        } else if (code === tokenExpiredCode) {
+          showInfoMessage("登录已失效");
+          await onUnauthorized?.();
+        } else if (code === accessDeniedCode) {
+          showWarningMessage(`${message}，请联系管理员为您开通`);
+          await onAccessDenied?.();
+        } else {
+          showWarningMessage(message);
+        }
+        throw new VefError(code, message);
+      },
+      (error) => {
+        if (error instanceof CanceledError) {
+          return Promise.reject(error);
+        }
+        const { response, message } = error;
+        if (response?.data) {
+          const errorMessage = `处理请求响应信息异常：${message ?? "无"}`;
+          return Promise.reject(new VefError(response.status, errorMessage));
+        } else {
+          let errorMessage = message ?? (isString(error) ? error : "");
+          if (errorMessage === "Network Error") {
+            errorMessage = "接口连接异常可能原因：网络不通或存在跨域问题。";
+          } else if (errorMessage.includes("timeout")) {
+            errorMessage = "接口请求超时";
+          } else if (errorMessage.includes("Request failed with status code")) {
+            const code = message.substring(message.length - 3);
+            errorMessage = `接口状态码异常：${code}`;
+          } else {
+            errorMessage = "接口未知异常";
+          }
+          showErrorMessage(errorMessage);
+          return Promise.reject(new VefError(-1, errorMessage));
+        }
+      }
+    );
+  }
+  /**
+   * Perform a GET request.
+   *
+   * @param url - The url.
+   * @param options - The request options.
+   * @returns The response data promise.
+   */
+  async get(url, options) {
+    const response = await __privateGet(this, _axiosInstance).get(url, {
+      params: options?.params,
+      headers: options?.headers,
+      signal: options?.signal
+    });
+    return response.data;
+  }
+  /**
+   * Perform a POST request.
+   *
+   * @param url - The url.
+   * @param data - The request data.
+   * @param options - The request options.
+   * @returns The response data promise.
+   */
+  async post(url, data, options) {
+    const response = await __privateGet(this, _axiosInstance).post(url, data, {
+      params: options?.params,
+      headers: options?.headers,
+      signal: options?.signal
+    });
+    return response.data;
+  }
+  /**
+   * Perform a PUT request.
+   *
+   * @param url - The url.
+   * @param data - The request data.
+   * @param options - The request options.
+   * @returns The response data promise.
+   */
+  async put(url, data, options) {
+    const response = await __privateGet(this, _axiosInstance).put(url, data, {
+      params: options?.params,
+      headers: options?.headers,
+      signal: options?.signal
+    });
+    return response.data;
+  }
+  /**
+   * Perform a DELETE request.
+   *
+   * @param url - The url.
+   * @param options - The request options.
+   * @returns The response data promise.
+   */
+  async delete(url, options) {
+    const response = await __privateGet(this, _axiosInstance).delete(url, {
+      params: options?.params,
+      headers: options?.headers,
+      signal: options?.signal
+    });
+    return response.data;
+  }
+  /**
+   * Perform a file upload request.
+   *
+   * @param url - The url.
+   * @param data - The file data.
+   * @param options - The request options.
+   * @returns The response data promise.
+   */
+  async upload(url, data, options) {
+    const response = await __privateGet(this, _axiosInstance).postForm(
+      url,
+      data,
+      {
+        params: options?.params,
+        headers: options?.headers,
+        signal: options?.signal,
+        onUploadProgress: isFunction(options?.onProgress) ? (progressEvent) => {
+          const total = progressEvent.lengthComputable ? progressEvent.total ?? 0 : 0;
+          const { loaded } = progressEvent;
+          const percent = Math.round(loaded / total * 100);
+          options.onProgress?.(percent);
+        } : void 0
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Perform a file download request.
+   *
+   * @param url - The url.
+   * @param options - The request options.
+   */
+  async download(url, options) {
+    const { data, headers } = await __privateGet(this, _axiosInstance).get(
+      url,
+      {
+        params: options?.params,
+        headers: options?.headers,
+        responseType: "blob",
+        onDownloadProgress: isFunction(options?.onProgress) ? (progressEvent) => {
+          const total = progressEvent.lengthComputable ? progressEvent.total ?? 0 : 0;
+          const { loaded } = progressEvent;
+          const percent = Math.round(loaded / total * 100);
+          options.onProgress?.(percent);
+        } : void 0
+      }
+    );
+    let response = null;
+    try {
+      response = JSON.parse(await data.text());
+    } catch {
+    }
+    if (response && response.code !== 0) {
+      throw new VefError(response.code, response.message);
+    }
+    const contentDisposition = headers.get("content-disposition");
+    if (isString(contentDisposition)) {
+      const fileNameRegex = /filename[^;=\n]*=(?<name>(?<quote>['"]).*?\2|[^;\n]*)/;
+      const matches = fileNameRegex.exec(contentDisposition);
+      if (matches && matches.groups) {
+        const { name } = matches.groups;
+        const fileName = decodeURIComponent(name);
+        const a = document.createElement("a");
+        a.href = URL.createObjectURL(data);
+        a.download = isFunction(options?.fileName) ? options.fileName(fileName) : options?.fileName ?? fileName;
+        a.click();
+        URL.revokeObjectURL(a.href);
+      }
+    }
+  }
+}
+_axiosInstance = new WeakMap();
+function createRequestClient(options) {
+  return Object.freeze(new RequestClient(options));
+}
+
+export { RequestClient, createRequestClient };

package/esm/auth/auth-context.js

@@ -0,0 +1,36 @@
+"use strict";
+import { isString, VefError } from '@vef-framework/shared';
+import { createContext, useMemo, createElement, useContext } from 'react';
+
+"use strict";
+const Context = createContext(null);
+const AuthContextProvider = ({
+  permissionChecker,
+  children
+}) => {
+  const authContext = useMemo(() => ({
+    checkPermission: (token) => {
+      if (!permissionChecker) {
+        return true;
+      }
+      if (isString(token)) {
+        return permissionChecker(token);
+      }
+      return permissionChecker(token.key);
+    }
+  }), [permissionChecker]);
+  return createElement(
+    Context.Provider,
+    { value: authContext },
+    children
+  );
+};
+function useAuthContext() {
+  const context = useContext(Context);
+  if (context === null) {
+    throw new VefError(-1, "useAuthContext must be used within a AuthContextProvider");
+  }
+  return context;
+}
+
+export { AuthContextProvider, useAuthContext };

package/esm/auth/index.js

@@ -0,0 +1,4 @@
+"use strict";
+export { AuthContextProvider, useAuthContext } from './auth-context.js';
+
+"use strict";

package/esm/expr/compiler.js

@@ -0,0 +1,300 @@
+"use strict";
+import { parseArgs, getAt, isQuotedString, rmEscapes } from './helpers.js';
+
+"use strict";
+function compile(expr) {
+  let provideTokens;
+  const requirements = /* @__PURE__ */ new Set();
+  const x = function expand(operand, tokens) {
+    return typeof operand === "function" ? operand(tokens) : operand;
+  };
+  const operatorRegistry = [
+    {
+      "&&": (l, r, t) => x(l, t) && x(r, t),
+      "||": (l, r, t) => x(l, t) || x(r, t)
+    },
+    {
+      "===": (l, r, t) => !!(x(l, t) === x(r, t)),
+      "!==": (l, r, t) => !!(x(l, t) !== x(r, t)),
+      // eslint-disable-next-line eqeqeq
+      "==": (l, r, t) => !!(x(l, t) == x(r, t)),
+      // eslint-disable-next-line eqeqeq
+      "!=": (l, r, t) => !!(x(l, t) != x(r, t)),
+      ">=": (l, r, t) => !!(x(l, t) >= x(r, t)),
+      "<=": (l, r, t) => !!(x(l, t) <= x(r, t)),
+      ">": (l, r, t) => !!(x(l, t) > x(r, t)),
+      "<": (l, r, t) => !!(x(l, t) < x(r, t))
+    },
+    {
+      "+": (l, r, t) => x(l, t) + x(r, t),
+      "-": (l, r, t) => x(l, t) - x(r, t)
+    },
+    {
+      "*": (l, r, t) => x(l, t) * x(r, t),
+      "/": (l, r, t) => x(l, t) / x(r, t),
+      "%": (l, r, t) => x(l, t) % x(r, t)
+    }
+  ];
+  const operatorSymbols = operatorRegistry.reduce((s, g) => s.concat(Object.keys(g)), []);
+  const operatorChars = new Set(operatorSymbols.map((key) => key.charAt(0)));
+  function getOp(symbols, char, p, expression) {
+    const candidates = symbols.filter((s) => s.startsWith(char));
+    if (!candidates.length) {
+      return false;
+    }
+    return candidates.find((symbol) => {
+      if (expression.length >= p + symbol.length) {
+        const nextChars = expression.substring(p, p + symbol.length);
+        if (nextChars === symbol) {
+          return symbol;
+        }
+      }
+      return false;
+    });
+  }
+  function getStep(p, expression, direction = 1) {
+    let next = direction ? expression.substring(p + 1).trim() : expression.substring(0, p).trim();
+    if (!next.length) {
+      return -1;
+    }
+    if (!direction) {
+      const reversed = next.split("").reverse();
+      const start = reversed.findIndex((char2) => operatorChars.has(char2));
+      next = reversed.slice(start).join("");
+    }
+    const [char] = next;
+    return operatorRegistry.findIndex((operators) => {
+      const symbols = Object.keys(operators);
+      return !!getOp(symbols, char, 0, next);
+    });
+  }
+  function getTail(pos, expression) {
+    let tail = "";
+    const { length } = expression;
+    let depth = 0;
+    for (let p = pos; p < length; p++) {
+      const char = expression.charAt(p);
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth--;
+      } else if (depth === 0 && char === " ") {
+        continue;
+      }
+      if (depth === 0 && getOp(operatorSymbols, char, p, expression)) {
+        return [tail, p - 1];
+      } else {
+        tail += char;
+      }
+    }
+    return [tail, expression.length - 1];
+  }
+  function compileExpr(expression, step = 0) {
+    const operators = operatorRegistry[step];
+    const { length } = expression;
+    const symbols = Object.keys(operators);
+    let depth = 0;
+    let quote = false;
+    let op = null;
+    let operand = "";
+    let left = null;
+    let operation;
+    let lastChar;
+    let char = "";
+    let parenthetical = "";
+    let parenQuote = "";
+    let startP = 0;
+    const addTo = (depth2, char2) => {
+      if (depth2) {
+        parenthetical += char2;
+      } else {
+        operand += char2;
+      }
+    };
+    for (let p = 0; p < length; p++) {
+      lastChar = char;
+      char = expression.charAt(p);
+      if ((char === "'" || char === '"') && lastChar !== "\\" && (depth === 0 && !quote || depth && !parenQuote)) {
+        if (depth) {
+          parenQuote = char;
+        } else {
+          quote = char;
+        }
+        addTo(depth, char);
+        continue;
+      } else if (quote && (char !== quote || lastChar === "\\") || parenQuote && (char !== parenQuote || lastChar === "\\")) {
+        addTo(depth, char);
+        continue;
+      } else if (quote === char) {
+        quote = false;
+        addTo(depth, char);
+        continue;
+      } else if (parenQuote === char) {
+        parenQuote = false;
+        addTo(depth, char);
+        continue;
+      } else if (char === " ") {
+        continue;
+      } else if (char === "(") {
+        if (depth === 0) {
+          startP = p;
+        } else {
+          parenthetical += char;
+        }
+        depth++;
+      } else if (char === ")") {
+        depth--;
+        if (depth === 0) {
+          const fn = typeof operand === "string" && operand.startsWith("$") ? operand : void 0;
+          const hasTail = fn && expression.charAt(p + 1) === ".";
+          let tail = "";
+          if (hasTail) {
+            [tail, p] = getTail(p + 2, expression);
+          }
+          const lStep = op ? step : getStep(startP, expression, 0);
+          const rStep = getStep(p, expression);
+          if (lStep === -1 && rStep === -1) {
+            operand = evaluate(parenthetical, -1, fn, tail);
+            if (typeof operand === "string") {
+              operand = parenthetical;
+            }
+          } else if (op && (lStep >= rStep || rStep === -1) && step === lStep) {
+            left = op.bind(null, evaluate(parenthetical, -1, fn, tail));
+            op = null;
+            operand = "";
+          } else if (rStep > lStep && step === rStep) {
+            operand = evaluate(parenthetical, -1, fn, tail);
+          } else {
+            operand += `(${parenthetical})${hasTail ? `.${tail}` : ""}`;
+          }
+          parenthetical = "";
+        } else {
+          parenthetical += char;
+        }
+      } else if (depth === 0 && (operation = getOp(symbols, char, p, expression))) {
+        if (p === 0) {
+          console.error(103, [operation, expression]);
+        }
+        p += operation.length - 1;
+        if (p === expression.length - 1) {
+          console.error(104, [operation, expression]);
+        }
+        if (!op) {
+          if (left) {
+            op = operators[operation].bind(null, evaluate(left, step));
+            left = null;
+          } else {
+            op = operators[operation].bind(null, evaluate(operand, step));
+            operand = "";
+          }
+        } else if (operand) {
+          left = op.bind(null, evaluate(operand, step));
+          op = operators[operation].bind(null, left);
+          operand = "";
+        }
+        continue;
+      } else {
+        addTo(depth, char);
+      }
+    }
+    if (operand && op) {
+      op = op.bind(null, evaluate(operand, step));
+    }
+    op = !op && left ? left : op;
+    if (!op && operand) {
+      op = (v, t) => typeof v === "function" ? v(t) : v;
+      op = op.bind(null, evaluate(operand, step));
+    }
+    if (!op && !operand) {
+      console.error(105, expression);
+    }
+    return op;
+  }
+  function evaluate(operand, step, fnToken, tail) {
+    if (fnToken) {
+      const fn = evaluate(fnToken, operatorRegistry.length);
+      let userFuncReturn;
+      let tailCall = tail ? compile(`$${tail}`) : false;
+      if (typeof fn === "function") {
+        const args = parseArgs(String(operand)).map(
+          (arg) => evaluate(arg, -1)
+        );
+        return (tokens) => {
+          const userFunc = fn(tokens);
+          if (typeof userFunc !== "function") {
+            console.warn(150, fnToken);
+            return userFunc;
+          }
+          userFuncReturn = userFunc(
+            ...args.map(
+              (arg) => typeof arg === "function" ? arg(tokens) : arg
+            )
+          );
+          if (tailCall) {
+            tailCall = tailCall.provide((subTokens) => {
+              const rootTokens = provideTokens(subTokens);
+              const t = subTokens.reduce(
+                (tokenSet, token) => {
+                  const isTail = token === tail || tail?.startsWith(`${token}(`);
+                  if (isTail) {
+                    const value = getAt(userFuncReturn, token);
+                    tokenSet[token] = () => value;
+                  } else {
+                    tokenSet[token] = rootTokens[token];
+                  }
+                  return tokenSet;
+                },
+                {}
+              );
+              return t;
+            });
+          }
+          return tailCall ? tailCall() : userFuncReturn;
+        };
+      }
+    } else if (typeof operand === "string") {
+      if (operand === "true") {
+        return true;
+      }
+      if (operand === "false") {
+        return false;
+      }
+      if (operand === "undefined") {
+        return void 0;
+      }
+      if (isQuotedString(operand)) {
+        return rmEscapes(operand.substring(1, operand.length - 1));
+      }
+      if (!Number.isNaN(+operand)) {
+        return Number(operand);
+      }
+      if (step < operatorRegistry.length - 1) {
+        return compileExpr(operand, step + 1);
+      } else {
+        if (operand.startsWith("$")) {
+          const cleaned = operand.substring(1);
+          requirements.add(cleaned);
+          return function getToken(tokens) {
+            return cleaned in tokens ? tokens[cleaned]() : void 0;
+          };
+        }
+        return operand;
+      }
+    }
+    return operand;
+  }
+  const compiled = compileExpr(expr);
+  const identifiers = Array.from(requirements);
+  function provide(callback) {
+    provideTokens = callback;
+    return Object.assign(
+      compiled.bind(null, callback(identifiers)),
+      { provide }
+    );
+  }
+  return Object.assign(compiled, {
+    provide
+  });
+}
+
+export { compile };

package/esm/expr/helpers.js

@@ -0,0 +1,87 @@
+"use strict";
+"use strict";
+function has(obj, property) {
+  return Object.hasOwn(obj, property);
+}
+function getAt(obj, addr) {
+  if (!obj || typeof obj !== "object") {
+    return null;
+  }
+  const segments = addr.split(".");
+  let o = obj;
+  for (const i in segments) {
+    const segment = segments[i];
+    if (has(o, segment)) {
+      o = o[segment];
+    }
+    if (+i === segments.length - 1) {
+      return o;
+    }
+    if (!o || typeof o !== "object") {
+      return null;
+    }
+  }
+  return null;
+}
+function isQuotedString(str) {
+  if (str[0] !== '"' && str[0] !== "'") {
+    return false;
+  }
+  if (str[0] !== str[str.length - 1]) {
+    return false;
+  }
+  const [quoteType] = str;
+  for (let p = 1; p < str.length; p++) {
+    if (str[p] === quoteType && (p === 1 || str[p - 1] !== "\\") && p !== str.length - 1) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseArgs(str) {
+  const args = [];
+  let arg = "";
+  let depth = 0;
+  let quote = "";
+  let lastChar = "";
+  for (let p = 0; p < str.length; p++) {
+    const char = str.charAt(p);
+    if (char === quote && lastChar !== "\\") {
+      quote = "";
+    } else if ((char === "'" || char === '"') && !quote && lastChar !== "\\") {
+      quote = char;
+    } else if (char === "(" && !quote) {
+      depth++;
+    } else if (char === ")" && !quote) {
+      depth--;
+    }
+    if (char === "," && !quote && depth === 0) {
+      args.push(arg);
+      arg = "";
+    } else if (char !== " " || quote) {
+      arg += char;
+    }
+    lastChar = char;
+  }
+  if (arg) {
+    args.push(arg);
+  }
+  return args;
+}
+function rmEscapes(str) {
+  if (!str.length) {
+    return "";
+  }
+  let clean = "";
+  let lastChar = "";
+  for (let p = 0; p < str.length; p++) {
+    const char = str.charAt(p);
+    if (char !== "\\" || lastChar === "\\") {
+      clean += char;
+    }
+    lastChar = char;
+  }
+  return clean;
+}
+
+export { getAt, has, isQuotedString, parseArgs, rmEscapes };