openxiangda 1.0.85 → 1.0.87

package/packages/sdk/dist/runtime/react.mjs

@@ -1,11 +1,2462 @@
+// packages/sdk/src/runtime/react/createReactPage.tsx
+import { StyleProvider } from "@ant-design/cssinjs";
+import { App as AntdApp, ConfigProvider, message } from "antd";
+import zhCN from "antd/locale/zh_CN.js";
+import dayjs3 from "dayjs";
+
+// node_modules/dayjs/esm/constant.js
+var SECONDS_A_MINUTE = 60;
+var SECONDS_A_HOUR = SECONDS_A_MINUTE * 60;
+var SECONDS_A_DAY = SECONDS_A_HOUR * 24;
+var SECONDS_A_WEEK = SECONDS_A_DAY * 7;
+var MILLISECONDS_A_SECOND = 1e3;
+var MILLISECONDS_A_MINUTE = SECONDS_A_MINUTE * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_HOUR = SECONDS_A_HOUR * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_DAY = SECONDS_A_DAY * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_WEEK = SECONDS_A_WEEK * MILLISECONDS_A_SECOND;
+var MS = "millisecond";
+var S = "second";
+var MIN = "minute";
+var H = "hour";
+var D = "day";
+var W = "week";
+var M = "month";
+var Q = "quarter";
+var Y = "year";
+var DATE = "date";
+var FORMAT_DEFAULT = "YYYY-MM-DDTHH:mm:ssZ";
+var INVALID_DATE_STRING = "Invalid Date";
+var REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+var REGEX_FORMAT = /\[([^\]]+)]|YYYY|YY|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
+
+// node_modules/dayjs/esm/locale/en.js
+var en_default = {
+  name: "en",
+  weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+  months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+  ordinal: function ordinal(n) {
+    var s = ["th", "st", "nd", "rd"];
+    var v = n % 100;
+    return "[" + n + (s[(v - 20) % 10] || s[v] || s[0]) + "]";
+  }
+};
+
+// node_modules/dayjs/esm/utils.js
+var padStart = function padStart2(string, length, pad) {
+  var s = String(string);
+  if (!s || s.length >= length) return string;
+  return "" + Array(length + 1 - s.length).join(pad) + string;
+};
+var padZoneStr = function padZoneStr2(instance) {
+  var negMinutes = -instance.utcOffset();
+  var minutes = Math.abs(negMinutes);
+  var hourOffset = Math.floor(minutes / 60);
+  var minuteOffset = minutes % 60;
+  return (negMinutes <= 0 ? "+" : "-") + padStart(hourOffset, 2, "0") + ":" + padStart(minuteOffset, 2, "0");
+};
+var monthDiff = function monthDiff2(a, b) {
+  if (a.date() < b.date()) return -monthDiff2(b, a);
+  var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month());
+  var anchor = a.clone().add(wholeMonthDiff, M);
+  var c = b - anchor < 0;
+  var anchor2 = a.clone().add(wholeMonthDiff + (c ? -1 : 1), M);
+  return +(-(wholeMonthDiff + (b - anchor) / (c ? anchor - anchor2 : anchor2 - anchor)) || 0);
+};
+var absFloor = function absFloor2(n) {
+  return n < 0 ? Math.ceil(n) || 0 : Math.floor(n);
+};
+var prettyUnit = function prettyUnit2(u) {
+  var special = {
+    M,
+    y: Y,
+    w: W,
+    d: D,
+    D: DATE,
+    h: H,
+    m: MIN,
+    s: S,
+    ms: MS,
+    Q
+  };
+  return special[u] || String(u || "").toLowerCase().replace(/s$/, "");
+};
+var isUndefined = function isUndefined2(s) {
+  return s === void 0;
+};
+var utils_default = {
+  s: padStart,
+  z: padZoneStr,
+  m: monthDiff,
+  a: absFloor,
+  p: prettyUnit,
+  u: isUndefined
+};
+
+// node_modules/dayjs/esm/index.js
+var L = "en";
+var Ls = {};
+Ls[L] = en_default;
+var IS_DAYJS = "$isDayjsObject";
+var isDayjs = function isDayjs2(d) {
+  return d instanceof Dayjs || !!(d && d[IS_DAYJS]);
+};
+var parseLocale = function parseLocale2(preset, object, isLocal) {
+  var l;
+  if (!preset) return L;
+  if (typeof preset === "string") {
+    var presetLower = preset.toLowerCase();
+    if (Ls[presetLower]) {
+      l = presetLower;
+    }
+    if (object) {
+      Ls[presetLower] = object;
+      l = presetLower;
+    }
+    var presetSplit = preset.split("-");
+    if (!l && presetSplit.length > 1) {
+      return parseLocale2(presetSplit[0]);
+    }
+  } else {
+    var name = preset.name;
+    Ls[name] = preset;
+    l = name;
+  }
+  if (!isLocal && l) L = l;
+  return l || !isLocal && L;
+};
+var dayjs = function dayjs2(date, c) {
+  if (isDayjs(date)) {
+    return date.clone();
+  }
+  var cfg = typeof c === "object" ? c : {};
+  cfg.date = date;
+  cfg.args = arguments;
+  return new Dayjs(cfg);
+};
+var wrapper = function wrapper2(date, instance) {
+  return dayjs(date, {
+    locale: instance.$L,
+    utc: instance.$u,
+    x: instance.$x,
+    $offset: instance.$offset
+    // todo: refactor; do not use this.$offset in you code
+  });
+};
+var Utils = utils_default;
+Utils.l = parseLocale;
+Utils.i = isDayjs;
+Utils.w = wrapper;
+var parseDate = function parseDate2(cfg) {
+  var date = cfg.date, utc = cfg.utc;
+  if (date === null) return /* @__PURE__ */ new Date(NaN);
+  if (Utils.u(date)) return /* @__PURE__ */ new Date();
+  if (date instanceof Date) return new Date(date);
+  if (typeof date === "string" && !/Z$/i.test(date)) {
+    var d = date.match(REGEX_PARSE);
+    if (d) {
+      var m = d[2] - 1 || 0;
+      var ms = (d[7] || "0").substring(0, 3);
+      if (utc) {
+        return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms));
+      }
+      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
+    }
+  }
+  return new Date(date);
+};
+var Dayjs = /* @__PURE__ */ (function() {
+  function Dayjs2(cfg) {
+    this.$L = parseLocale(cfg.locale, null, true);
+    this.parse(cfg);
+    this.$x = this.$x || cfg.x || {};
+    this[IS_DAYJS] = true;
+  }
+  var _proto = Dayjs2.prototype;
+  _proto.parse = function parse(cfg) {
+    this.$d = parseDate(cfg);
+    this.init();
+  };
+  _proto.init = function init() {
+    var $d = this.$d;
+    this.$y = $d.getFullYear();
+    this.$M = $d.getMonth();
+    this.$D = $d.getDate();
+    this.$W = $d.getDay();
+    this.$H = $d.getHours();
+    this.$m = $d.getMinutes();
+    this.$s = $d.getSeconds();
+    this.$ms = $d.getMilliseconds();
+  };
+  _proto.$utils = function $utils() {
+    return Utils;
+  };
+  _proto.isValid = function isValid() {
+    return !(this.$d.toString() === INVALID_DATE_STRING);
+  };
+  _proto.isSame = function isSame(that, units) {
+    var other = dayjs(that);
+    return this.startOf(units) <= other && other <= this.endOf(units);
+  };
+  _proto.isAfter = function isAfter(that, units) {
+    return dayjs(that) < this.startOf(units);
+  };
+  _proto.isBefore = function isBefore(that, units) {
+    return this.endOf(units) < dayjs(that);
+  };
+  _proto.$g = function $g(input, get, set) {
+    if (Utils.u(input)) return this[get];
+    return this.set(set, input);
+  };
+  _proto.unix = function unix() {
+    return Math.floor(this.valueOf() / 1e3);
+  };
+  _proto.valueOf = function valueOf() {
+    return this.$d.getTime();
+  };
+  _proto.startOf = function startOf(units, _startOf) {
+    var _this = this;
+    var isStartOf = !Utils.u(_startOf) ? _startOf : true;
+    var unit = Utils.p(units);
+    var instanceFactory = function instanceFactory2(d, m) {
+      var ins = Utils.w(_this.$u ? Date.UTC(_this.$y, m, d) : new Date(_this.$y, m, d), _this);
+      return isStartOf ? ins : ins.endOf(D);
+    };
+    var instanceFactorySet = function instanceFactorySet2(method, slice) {
+      var argumentStart = [0, 0, 0, 0];
+      var argumentEnd = [23, 59, 59, 999];
+      return Utils.w(_this.toDate()[method].apply(
+        // eslint-disable-line prefer-spread
+        _this.toDate("s"),
+        (isStartOf ? argumentStart : argumentEnd).slice(slice)
+      ), _this);
+    };
+    var $W = this.$W, $M = this.$M, $D = this.$D;
+    var utcPad = "set" + (this.$u ? "UTC" : "");
+    switch (unit) {
+      case Y:
+        return isStartOf ? instanceFactory(1, 0) : instanceFactory(31, 11);
+      case M:
+        return isStartOf ? instanceFactory(1, $M) : instanceFactory(0, $M + 1);
+      case W: {
+        var weekStart = this.$locale().weekStart || 0;
+        var gap = ($W < weekStart ? $W + 7 : $W) - weekStart;
+        return instanceFactory(isStartOf ? $D - gap : $D + (6 - gap), $M);
+      }
+      case D:
+      case DATE:
+        return instanceFactorySet(utcPad + "Hours", 0);
+      case H:
+        return instanceFactorySet(utcPad + "Minutes", 1);
+      case MIN:
+        return instanceFactorySet(utcPad + "Seconds", 2);
+      case S:
+        return instanceFactorySet(utcPad + "Milliseconds", 3);
+      default:
+        return this.clone();
+    }
+  };
+  _proto.endOf = function endOf(arg) {
+    return this.startOf(arg, false);
+  };
+  _proto.$set = function $set(units, _int) {
+    var _C$D$C$DATE$C$M$C$Y$C;
+    var unit = Utils.p(units);
+    var utcPad = "set" + (this.$u ? "UTC" : "");
+    var name = (_C$D$C$DATE$C$M$C$Y$C = {}, _C$D$C$DATE$C$M$C$Y$C[D] = utcPad + "Date", _C$D$C$DATE$C$M$C$Y$C[DATE] = utcPad + "Date", _C$D$C$DATE$C$M$C$Y$C[M] = utcPad + "Month", _C$D$C$DATE$C$M$C$Y$C[Y] = utcPad + "FullYear", _C$D$C$DATE$C$M$C$Y$C[H] = utcPad + "Hours", _C$D$C$DATE$C$M$C$Y$C[MIN] = utcPad + "Minutes", _C$D$C$DATE$C$M$C$Y$C[S] = utcPad + "Seconds", _C$D$C$DATE$C$M$C$Y$C[MS] = utcPad + "Milliseconds", _C$D$C$DATE$C$M$C$Y$C)[unit];
+    var arg = unit === D ? this.$D + (_int - this.$W) : _int;
+    if (unit === M || unit === Y) {
+      var date = this.clone().set(DATE, 1);
+      date.$d[name](arg);
+      date.init();
+      this.$d = date.set(DATE, Math.min(this.$D, date.daysInMonth())).$d;
+    } else if (name) this.$d[name](arg);
+    this.init();
+    return this;
+  };
+  _proto.set = function set(string, _int2) {
+    return this.clone().$set(string, _int2);
+  };
+  _proto.get = function get(unit) {
+    return this[Utils.p(unit)]();
+  };
+  _proto.add = function add(number, units) {
+    var _this2 = this, _C$MIN$C$H$C$S$unit;
+    number = Number(number);
+    var unit = Utils.p(units);
+    var instanceFactorySet = function instanceFactorySet2(n) {
+      var d = dayjs(_this2);
+      return Utils.w(d.date(d.date() + Math.round(n * number)), _this2);
+    };
+    if (unit === M) {
+      return this.set(M, this.$M + number);
+    }
+    if (unit === Y) {
+      return this.set(Y, this.$y + number);
+    }
+    if (unit === D) {
+      return instanceFactorySet(1);
+    }
+    if (unit === W) {
+      return instanceFactorySet(7);
+    }
+    var step = (_C$MIN$C$H$C$S$unit = {}, _C$MIN$C$H$C$S$unit[MIN] = MILLISECONDS_A_MINUTE, _C$MIN$C$H$C$S$unit[H] = MILLISECONDS_A_HOUR, _C$MIN$C$H$C$S$unit[S] = MILLISECONDS_A_SECOND, _C$MIN$C$H$C$S$unit)[unit] || 1;
+    var nextTimeStamp = this.$d.getTime() + number * step;
+    return Utils.w(nextTimeStamp, this);
+  };
+  _proto.subtract = function subtract(number, string) {
+    return this.add(number * -1, string);
+  };
+  _proto.format = function format(formatStr) {
+    var _this3 = this;
+    var locale2 = this.$locale();
+    if (!this.isValid()) return locale2.invalidDate || INVALID_DATE_STRING;
+    var str = formatStr || FORMAT_DEFAULT;
+    var zoneStr = Utils.z(this);
+    var $H = this.$H, $m = this.$m, $M = this.$M;
+    var weekdays = locale2.weekdays, months = locale2.months, meridiem2 = locale2.meridiem;
+    var getShort = function getShort2(arr, index, full, length) {
+      return arr && (arr[index] || arr(_this3, str)) || full[index].slice(0, length);
+    };
+    var get$H = function get$H2(num) {
+      return Utils.s($H % 12 || 12, num, "0");
+    };
+    var meridiemFunc = meridiem2 || function(hour, minute, isLowercase) {
+      var m = hour < 12 ? "AM" : "PM";
+      return isLowercase ? m.toLowerCase() : m;
+    };
+    var matches = function matches2(match) {
+      switch (match) {
+        case "YY":
+          return String(_this3.$y).slice(-2);
+        case "YYYY":
+          return Utils.s(_this3.$y, 4, "0");
+        case "M":
+          return $M + 1;
+        case "MM":
+          return Utils.s($M + 1, 2, "0");
+        case "MMM":
+          return getShort(locale2.monthsShort, $M, months, 3);
+        case "MMMM":
+          return getShort(months, $M);
+        case "D":
+          return _this3.$D;
+        case "DD":
+          return Utils.s(_this3.$D, 2, "0");
+        case "d":
+          return String(_this3.$W);
+        case "dd":
+          return getShort(locale2.weekdaysMin, _this3.$W, weekdays, 2);
+        case "ddd":
+          return getShort(locale2.weekdaysShort, _this3.$W, weekdays, 3);
+        case "dddd":
+          return weekdays[_this3.$W];
+        case "H":
+          return String($H);
+        case "HH":
+          return Utils.s($H, 2, "0");
+        case "h":
+          return get$H(1);
+        case "hh":
+          return get$H(2);
+        case "a":
+          return meridiemFunc($H, $m, true);
+        case "A":
+          return meridiemFunc($H, $m, false);
+        case "m":
+          return String($m);
+        case "mm":
+          return Utils.s($m, 2, "0");
+        case "s":
+          return String(_this3.$s);
+        case "ss":
+          return Utils.s(_this3.$s, 2, "0");
+        case "SSS":
+          return Utils.s(_this3.$ms, 3, "0");
+        case "Z":
+          return zoneStr;
+        // 'ZZ' logic below
+        default:
+          break;
+      }
+      return null;
+    };
+    return str.replace(REGEX_FORMAT, function(match, $1) {
+      return $1 || matches(match) || zoneStr.replace(":", "");
+    });
+  };
+  _proto.utcOffset = function utcOffset() {
+    return -Math.round(this.$d.getTimezoneOffset() / 15) * 15;
+  };
+  _proto.diff = function diff(input, units, _float) {
+    var _this4 = this;
+    var unit = Utils.p(units);
+    var that = dayjs(input);
+    var zoneDelta = (that.utcOffset() - this.utcOffset()) * MILLISECONDS_A_MINUTE;
+    var diff2 = this - that;
+    var getMonth = function getMonth2() {
+      return Utils.m(_this4, that);
+    };
+    var result;
+    switch (unit) {
+      case Y:
+        result = getMonth() / 12;
+        break;
+      case M:
+        result = getMonth();
+        break;
+      case Q:
+        result = getMonth() / 3;
+        break;
+      case W:
+        result = (diff2 - zoneDelta) / MILLISECONDS_A_WEEK;
+        break;
+      case D:
+        result = (diff2 - zoneDelta) / MILLISECONDS_A_DAY;
+        break;
+      case H:
+        result = diff2 / MILLISECONDS_A_HOUR;
+        break;
+      case MIN:
+        result = diff2 / MILLISECONDS_A_MINUTE;
+        break;
+      case S:
+        result = diff2 / MILLISECONDS_A_SECOND;
+        break;
+      default:
+        result = diff2;
+        break;
+    }
+    return _float ? result : Utils.a(result);
+  };
+  _proto.daysInMonth = function daysInMonth() {
+    return this.endOf(M).$D;
+  };
+  _proto.$locale = function $locale() {
+    return Ls[this.$L];
+  };
+  _proto.locale = function locale2(preset, object) {
+    if (!preset) return this.$L;
+    var that = this.clone();
+    var nextLocaleName = parseLocale(preset, object, true);
+    if (nextLocaleName) that.$L = nextLocaleName;
+    return that;
+  };
+  _proto.clone = function clone() {
+    return Utils.w(this.$d, this);
+  };
+  _proto.toDate = function toDate() {
+    return new Date(this.valueOf());
+  };
+  _proto.toJSON = function toJSON() {
+    return this.isValid() ? this.toISOString() : null;
+  };
+  _proto.toISOString = function toISOString() {
+    return this.$d.toISOString();
+  };
+  _proto.toString = function toString() {
+    return this.$d.toUTCString();
+  };
+  return Dayjs2;
+})();
+var proto = Dayjs.prototype;
+dayjs.prototype = proto;
+[["$ms", MS], ["$s", S], ["$m", MIN], ["$H", H], ["$W", D], ["$M", M], ["$y", Y], ["$D", DATE]].forEach(function(g) {
+  proto[g[1]] = function(input) {
+    return this.$g(input, g[0], g[1]);
+  };
+});
+dayjs.extend = function(plugin, option) {
+  if (!plugin.$i) {
+    plugin(option, Dayjs, dayjs);
+    plugin.$i = true;
+  }
+  return dayjs;
+};
+dayjs.locale = parseLocale;
+dayjs.isDayjs = isDayjs;
+dayjs.unix = function(timestamp) {
+  return dayjs(timestamp * 1e3);
+};
+dayjs.en = Ls[L];
+dayjs.Ls = Ls;
+dayjs.p = {};
+var esm_default = dayjs;
+
+// node_modules/dayjs/esm/locale/zh-cn.js
+var locale = {
+  name: "zh-cn",
+  weekdays: "\u661F\u671F\u65E5_\u661F\u671F\u4E00_\u661F\u671F\u4E8C_\u661F\u671F\u4E09_\u661F\u671F\u56DB_\u661F\u671F\u4E94_\u661F\u671F\u516D".split("_"),
+  weekdaysShort: "\u5468\u65E5_\u5468\u4E00_\u5468\u4E8C_\u5468\u4E09_\u5468\u56DB_\u5468\u4E94_\u5468\u516D".split("_"),
+  weekdaysMin: "\u65E5_\u4E00_\u4E8C_\u4E09_\u56DB_\u4E94_\u516D".split("_"),
+  months: "\u4E00\u6708_\u4E8C\u6708_\u4E09\u6708_\u56DB\u6708_\u4E94\u6708_\u516D\u6708_\u4E03\u6708_\u516B\u6708_\u4E5D\u6708_\u5341\u6708_\u5341\u4E00\u6708_\u5341\u4E8C\u6708".split("_"),
+  monthsShort: "1\u6708_2\u6708_3\u6708_4\u6708_5\u6708_6\u6708_7\u6708_8\u6708_9\u6708_10\u6708_11\u6708_12\u6708".split("_"),
+  ordinal: function ordinal2(number, period) {
+    switch (period) {
+      case "W":
+        return number + "\u5468";
+      default:
+        return number + "\u65E5";
+    }
+  },
+  weekStart: 1,
+  yearStart: 4,
+  formats: {
+    LT: "HH:mm",
+    LTS: "HH:mm:ss",
+    L: "YYYY/MM/DD",
+    LL: "YYYY\u5E74M\u6708D\u65E5",
+    LLL: "YYYY\u5E74M\u6708D\u65E5Ah\u70B9mm\u5206",
+    LLLL: "YYYY\u5E74M\u6708D\u65E5ddddAh\u70B9mm\u5206",
+    l: "YYYY/M/D",
+    ll: "YYYY\u5E74M\u6708D\u65E5",
+    lll: "YYYY\u5E74M\u6708D\u65E5 HH:mm",
+    llll: "YYYY\u5E74M\u6708D\u65E5dddd HH:mm"
+  },
+  relativeTime: {
+    future: "%s\u5185",
+    past: "%s\u524D",
+    s: "\u51E0\u79D2",
+    m: "1 \u5206\u949F",
+    mm: "%d \u5206\u949F",
+    h: "1 \u5C0F\u65F6",
+    hh: "%d \u5C0F\u65F6",
+    d: "1 \u5929",
+    dd: "%d \u5929",
+    M: "1 \u4E2A\u6708",
+    MM: "%d \u4E2A\u6708",
+    y: "1 \u5E74",
+    yy: "%d \u5E74"
+  },
+  meridiem: function meridiem(hour, minute) {
+    var hm = hour * 100 + minute;
+    if (hm < 600) {
+      return "\u51CC\u6668";
+    } else if (hm < 900) {
+      return "\u65E9\u4E0A";
+    } else if (hm < 1100) {
+      return "\u4E0A\u5348";
+    } else if (hm < 1300) {
+      return "\u4E2D\u5348";
+    } else if (hm < 1800) {
+      return "\u4E0B\u5348";
+    }
+    return "\u665A\u4E0A";
+  }
+};
+esm_default.locale(locale, null, true);
+
+// packages/sdk/src/runtime/react/createReactPage.tsx
+import React2 from "react";
+import { createRoot } from "react-dom/client";
+
+// packages/sdk/src/runtime/react/provider.tsx
+import { useMemo } from "react";
+
+// packages/sdk/src/runtime/react/store.ts
+import { createContext, useContext } from "react";
+var ReactPageContext = createContext(null);
+var usePageSdkStore = () => {
+  const store = useContext(ReactPageContext);
+  if (!store) {
+    throw new Error("usePageSdkStore \u5FC5\u987B\u5728 PageProvider \u5185\u4F7F\u7528");
+  }
+  return store;
+};
+
+// packages/sdk/src/runtime/core/client.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isSearchRuleLike = (value) => isRecord(value) && typeof value.key === "string" && (value.componentName === void 0 || typeof value.componentName === "string");
+var isBlobLike = (value) => typeof Blob !== "undefined" && value instanceof Blob;
+var normalizeMethod = (value) => {
+  const method = String(value || "get").toLowerCase();
+  if (method === "get" || method === "post" || method === "put" || method === "delete" || method === "patch") {
+    return method;
+  }
+  return "get";
+};
+var resolveAppType = (context, explicitAppType) => {
+  const appType = String(explicitAppType || context.app.appType || "").trim();
+  if (!appType) {
+    throw new Error("appType \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  return appType;
+};
+var buildAppPath = (context, explicitAppType, suffix) => `/${resolveAppType(context, explicitAppType)}${suffix}`;
+var buildOpenXiangdaAppPath = (context, explicitAppType, suffix) => `/openxiangda-api/v1/apps/${encodePathSegment(
+  resolveAppType(context, explicitAppType)
+)}${suffix}`;
+var encodePathSegment = (value) => encodeURIComponent(String(value));
+var getHeaderValue = (headers, name) => {
+  if (!headers) {
+    return void 0;
+  }
+  const target = name.toLowerCase();
+  const entry = Object.entries(headers).find(
+    ([key]) => key.toLowerCase() === target
+  );
+  return entry ? String(entry[1]) : void 0;
+};
+var parseContentDispositionFileName = (contentDisposition) => {
+  if (!contentDisposition) {
+    return void 0;
+  }
+  const utf8Match = contentDisposition.match(/filename\*=UTF-8''([^;]+)/i);
+  if (utf8Match?.[1]) {
+    try {
+      return decodeURIComponent(utf8Match[1]);
+    } catch {
+      return utf8Match[1];
+    }
+  }
+  const quotedMatch = contentDisposition.match(/filename="([^"]+)"/i);
+  if (quotedMatch?.[1]) {
+    return quotedMatch[1];
+  }
+  const plainMatch = contentDisposition.match(/filename=([^;]+)/i);
+  if (plainMatch?.[1]) {
+    return plainMatch[1].trim();
+  }
+  return void 0;
+};
+var parseConnectorCallName = (name) => {
+  const value = String(name || "").trim();
+  const separatorIndex = value.indexOf(".");
+  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+    throw new Error("\u8FDE\u63A5\u5668\u8C03\u7528\u540D\u5FC5\u987B\u662F connector.api \u683C\u5F0F");
+  }
+  return {
+    connector: value.slice(0, separatorIndex),
+    api: value.slice(separatorIndex + 1)
+  };
+};
+var serializeQuery = (query) => {
+  if (!query) {
+    return void 0;
+  }
+  const params = new URLSearchParams();
+  const appendValue = (key, value) => {
+    if (value === void 0 || value === null || value === "") {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item) => appendValue(key, item));
+      return;
+    }
+    if (value instanceof Date) {
+      params.append(key, value.toISOString());
+      return;
+    }
+    params.append(key, String(value));
+  };
+  Object.entries(query).forEach(([key, value]) => {
+    appendValue(key, value);
+  });
+  const serialized = params.toString();
+  return serialized || void 0;
+};
+var toLegacyRules = (value) => Object.entries(value).flatMap(([key, itemValue]) => {
+  if (itemValue === void 0) {
+    return [];
+  }
+  return [
+    {
+      key,
+      operator: Array.isArray(itemValue) ? "IN" : "EQ",
+      value: itemValue
+    }
+  ];
+});
+var toSearchGroup = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    try {
+      return toSearchGroup(JSON.parse(value));
+    } catch {
+      return void 0;
+    }
+  }
+  if (Array.isArray(value)) {
+    const rules = [];
+    const conditions = [];
+    value.forEach((item) => {
+      const group = toSearchGroup(item);
+      if (group) {
+        if (group.rules?.length) {
+          rules.push(...group.rules);
+        }
+        if (group.conditions?.length) {
+          conditions.push(...group.conditions);
+        }
+        return;
+      }
+      if (isSearchRuleLike(item)) {
+        rules.push(item);
+        return;
+      }
+      if (isRecord(item)) {
+        rules.push(...toLegacyRules(item));
+      }
+    });
+    if (rules.length === 0 && conditions.length === 0) {
+      return void 0;
+    }
+    return {
+      logic: "AND",
+      ...rules.length > 0 ? { rules } : {},
+      ...conditions.length > 0 ? { conditions } : {}
+    };
+  }
+  if (isRecord(value)) {
+    if (isSearchRuleLike(value)) {
+      return {
+        logic: "AND",
+        rules: [value]
+      };
+    }
+    if ("rules" in value || "conditions" in value || "logic" in value) {
+      const nextGroup = {
+        logic: value.logic === "OR" || value.logic === "AND" ? value.logic : "AND"
+      };
+      if (Array.isArray(value.rules)) {
+        nextGroup.rules = value.rules.filter(isSearchRuleLike);
+      }
+      if (Array.isArray(value.conditions)) {
+        nextGroup.conditions = value.conditions.map((item) => toSearchGroup(item)).filter((item) => Boolean(item));
+      }
+      if (!nextGroup.rules?.length && !nextGroup.conditions?.length) {
+        return void 0;
+      }
+      return nextGroup;
+    }
+    const rules = toLegacyRules(value);
+    if (rules.length === 0) {
+      return void 0;
+    }
+    return {
+      logic: "AND",
+      rules
+    };
+  }
+  return void 0;
+};
+var mergeSearchExpressions = (base, extra) => {
+  const baseGroup = toSearchGroup(base);
+  const extraGroup = toSearchGroup(extra);
+  if (!baseGroup) {
+    return extraGroup;
+  }
+  if (!extraGroup) {
+    return baseGroup;
+  }
+  return {
+    logic: "AND",
+    conditions: [baseGroup, extraGroup]
+  };
+};
+var serializeSearchExpression = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  const group = toSearchGroup(value);
+  return group ? JSON.stringify(group) : void 0;
+};
+var normalizeAdvancedOrder = (value) => {
+  if (!value) {
+    return void 0;
+  }
+  const nextValue = Array.isArray(value) ? value : [value];
+  return JSON.stringify(nextValue);
+};
+var normalizeDynamicOrder = (value) => {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return `${value.id}:${value.isAsc === "n" ? "-" : "+"}`;
+};
+var normalizeJsonResponse = (rawResponse) => {
+  const topLevelCode = Number(rawResponse?.code);
+  const nestedCode = Number(
+    rawResponse?.data?.code
+  );
+  const code = Number.isFinite(topLevelCode) ? topLevelCode : Number.isFinite(nestedCode) ? nestedCode : 200;
+  const topLevelResult = isRecord(rawResponse) && "result" in rawResponse ? rawResponse.result : void 0;
+  const nestedResult = isRecord(rawResponse?.data) && "result" in (rawResponse.data || {}) ? rawResponse.data?.result : void 0;
+  const topLevelData = isRecord(rawResponse) && "data" in rawResponse ? rawResponse.data : void 0;
+  const result = topLevelResult !== void 0 ? topLevelResult : nestedResult !== void 0 ? nestedResult : topLevelData !== void 0 ? topLevelData : isRecord(rawResponse) ? rawResponse : null;
+  const nestedSuccess = typeof rawResponse?.data?.success === "boolean" ? rawResponse.data?.success : void 0;
+  const success = typeof rawResponse?.success === "boolean" ? Boolean(rawResponse.success) : typeof nestedSuccess === "boolean" ? Boolean(nestedSuccess) : code >= 200 && code < 300;
+  return {
+    code,
+    success,
+    message: typeof rawResponse?.message === "string" ? rawResponse.message : typeof rawResponse?.data?.message === "string" ? rawResponse.data?.message : void 0,
+    result,
+    data: topLevelData !== void 0 ? topLevelData : topLevelResult !== void 0 ? topLevelResult : void 0,
+    raw: rawResponse
+  };
+};
+var normalizeBinaryResponse = (rawResponse) => {
+  if (isRecord(rawResponse) && isBlobLike(rawResponse.blob)) {
+    return rawResponse;
+  }
+  if (isBlobLike(rawResponse)) {
+    return {
+      blob: rawResponse,
+      raw: rawResponse
+    };
+  }
+  const responseData = rawResponse?.data;
+  const responseHeaders = isRecord(
+    rawResponse?.headers
+  ) ? rawResponse.headers : void 0;
+  if (!isBlobLike(responseData)) {
+    throw new Error("transport.download \u672A\u8FD4\u56DE Blob \u6570\u636E");
+  }
+  const contentDisposition = getHeaderValue(
+    responseHeaders,
+    "content-disposition"
+  );
+  return {
+    blob: responseData,
+    fileName: parseContentDispositionFileName(contentDisposition),
+    contentType: getHeaderValue(responseHeaders, "content-type") || responseData.type,
+    headers: responseHeaders ? Object.fromEntries(
+      Object.entries(responseHeaders).map(([key, value]) => [
+        key,
+        value === void 0 ? void 0 : String(value)
+      ])
+    ) : void 0,
+    raw: rawResponse
+  };
+};
+var toSdkError = (input, payload) => {
+  const normalizedResponse = isRecord(input) ? normalizeJsonResponse(input) : void 0;
+  const nextError = input instanceof Error ? input : new Error(
+    normalizedResponse?.message || `\u8BF7\u6C42\u5931\u8D25: ${String(payload.method).toUpperCase()} ${payload.path}`
+  );
+  const sdkError = nextError;
+  sdkError.method = String(payload.method).toUpperCase();
+  sdkError.path = payload.path;
+  sdkError.response = normalizedResponse;
+  sdkError.raw = input;
+  return sdkError;
+};
+var ensureSuccess = (response, payload) => {
+  if (!response.success) {
+    throw toSdkError(response, payload);
+  }
+  return response;
+};
+var resolveFormInstanceId = (params) => {
+  const formInstanceId = String(
+    params.formInstId || params.formInstanceId || ""
+  ).trim();
+  if (!formInstanceId) {
+    throw new Error("formInstanceId \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  return formInstanceId;
+};
+var withDefaultAppType = (context, params) => {
+  if (!params) {
+    return params;
+  }
+  if (params.appType) {
+    return params;
+  }
+  if (params.scope === "app") {
+    return {
+      ...params,
+      appType: context.app.appType
+    };
+  }
+  return params;
+};
+var AUTH_LOGIN_URL_ENV_KEYS = [
+  "loginUrl",
+  "authLoginUrl",
+  "bathAuthUrl",
+  "REACT_APP_VITE_BATH_AUTH_URL",
+  "VITE_BATH_AUTH_URL",
+  "BATH_AUTH_URL"
+];
+var DEFAULT_PLATFORM_LOGIN_URL = "/platform/login";
+var normalizeOptionalString = (value) => {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text || void 0;
+};
+var getCurrentHref = () => {
+  if (typeof window === "undefined") {
+    return "";
+  }
+  return window.location?.href || "";
+};
+var resolveAuthLoginUrl = (context, options) => {
+  const explicitLoginUrl = normalizeOptionalString(options.loginUrl);
+  if (explicitLoginUrl) {
+    return explicitLoginUrl;
+  }
+  for (const key of AUTH_LOGIN_URL_ENV_KEYS) {
+    const loginUrl = normalizeOptionalString(context.env?.[key]);
+    if (loginUrl) {
+      return loginUrl;
+    }
+  }
+  return void 0;
+};
+var buildAuthRedirectUrl = (loginUrl, callbackUrl, callbackParamName) => {
+  const paramName = normalizeOptionalString(callbackParamName) || "callback";
+  const normalizedCallbackUrl = normalizeOptionalString(callbackUrl);
+  if (!normalizedCallbackUrl) {
+    return loginUrl;
+  }
+  const baseHref = getCurrentHref() || "http://localhost/";
+  const isAbsoluteUrl = /^[a-z][a-z\d+.-]*:/i.test(loginUrl);
+  const isProtocolRelativeUrl = loginUrl.startsWith("//");
+  const isRootRelativeUrl = loginUrl.startsWith("/");
+  try {
+    const url = new URL(loginUrl, baseHref);
+    url.searchParams.set(paramName, normalizedCallbackUrl);
+    if (isAbsoluteUrl || isProtocolRelativeUrl) {
+      return url.toString();
+    }
+    const path = `${url.pathname}${url.search}${url.hash}`;
+    return isRootRelativeUrl ? path : path.replace(/^\//, "");
+  } catch {
+    const hashIndex = loginUrl.indexOf("#");
+    const pathAndQuery = hashIndex >= 0 ? loginUrl.slice(0, hashIndex) : loginUrl;
+    const hash = hashIndex >= 0 ? loginUrl.slice(hashIndex) : "";
+    const separator = pathAndQuery.includes("?") ? "&" : "?";
+    return `${pathAndQuery}${separator}${encodeURIComponent(
+      paramName
+    )}=${encodeURIComponent(normalizedCallbackUrl)}${hash}`;
+  }
+};
+var performRedirect = (url, options) => {
+  if (options.redirect) {
+    options.redirect(url);
+    return;
+  }
+  if (typeof window === "undefined" || !window.location) {
+    return;
+  }
+  if (options.replace && typeof window.location.replace === "function") {
+    window.location.replace(url);
+    return;
+  }
+  window.location.href = url;
+};
+var reloadCurrentPage = () => {
+  if (typeof window === "undefined" || !window.location || typeof window.location.reload !== "function") {
+    return;
+  }
+  window.location.reload();
+};
+var redirectAfterLogout = (context, options) => {
+  const loginUrl = resolveAuthLoginUrl(context, options);
+  const callbackUrl = normalizeOptionalString(options.callbackUrl) || getCurrentHref();
+  if (loginUrl) {
+    performRedirect(
+      buildAuthRedirectUrl(loginUrl, callbackUrl, options.callbackParamName),
+      options
+    );
+    return;
+  }
+  if (options.fallback === "none") {
+    return;
+  }
+  if (options.fallback === "reload") {
+    reloadCurrentPage();
+    return;
+  }
+  const redirectLoginUrl = DEFAULT_PLATFORM_LOGIN_URL;
+  performRedirect(
+    buildAuthRedirectUrl(redirectLoginUrl, callbackUrl, options.callbackParamName),
+    options
+  );
+};
+var createPageSdk = (context) => {
+  const request = async (options) => {
+    const payload = {
+      path: options.path,
+      method: normalizeMethod(options.method),
+      query: serializeQuery(options.query),
+      body: options.body,
+      headers: options.headers
+    };
+    try {
+      const rawResponse = await context.bridge.invoke(
+        "transport.request",
+        payload
+      );
+      return ensureSuccess(
+        normalizeJsonResponse(rawResponse),
+        payload
+      );
+    } catch (error) {
+      throw toSdkError(error, payload);
+    }
+  };
+  const download = async (options) => {
+    const payload = {
+      path: options.path,
+      method: normalizeMethod(options.method),
+      query: serializeQuery(options.query),
+      body: options.body,
+      headers: options.headers
+    };
+    try {
+      const rawResponse = await context.bridge.invoke(
+        "transport.download",
+        payload
+      );
+      return normalizeBinaryResponse(rawResponse);
+    } catch (error) {
+      throw toSdkError(error, payload);
+    }
+  };
+  const logout = () => request({
+    path: "/api/auth/logout",
+    method: "post"
+  });
+  const auth = {
+    logout,
+    logoutAndRedirect: async (options = {}) => {
+      try {
+        const response = await logout();
+        redirectAfterLogout(context, options);
+        return response;
+      } catch (error) {
+        if (options.continueOnLogoutError === false) {
+          throw error;
+        }
+        redirectAfterLogout(context, options);
+        return null;
+      }
+    }
+  };
+  const connector = {
+    invoke: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/connectors/actions/invoke"
+      ),
+      method: "post",
+      body: {
+        connector: params.connector,
+        api: params.api,
+        pathParams: params.pathParams,
+        query: params.query,
+        body: params.body,
+        headers: params.headers,
+        requestBodyType: params.requestBodyType,
+        responseType: params.responseType
+      }
+    }),
+    call: (name, params = {}) => {
+      const target = parseConnectorCallName(name);
+      return connector.invoke({
+        ...params,
+        connector: target.connector,
+        api: target.api
+      });
+    },
+    download: (params) => download({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/connectors/actions/download"
+      ),
+      method: "post",
+      body: {
+        connector: params.connector,
+        api: params.api,
+        pathParams: params.pathParams,
+        query: params.query,
+        body: params.body,
+        headers: params.headers,
+        requestBodyType: params.requestBodyType,
+        responseType: "binary"
+      }
+    })
+  };
+  const form = {
+    getDetail: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/getFormDataById.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        formInstId: resolveFormInstanceId(params)
+      }
+    }),
+    create: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/saveFormData.json"
+      ),
+      method: "post",
+      body: {
+        formUuid: params.formUuid,
+        formDataJson: JSON.stringify(params.data || {})
+      }
+    }),
+    update: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/updateFormData.json"
+      ),
+      method: "post",
+      body: {
+        formUuid: params.formUuid,
+        formInstId: resolveFormInstanceId(params),
+        updateFormDataJson: params.updateFormDataJson || JSON.stringify(params.data || {})
+      }
+    }),
+    remove: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/deleteFormData.json"
+      ),
+      method: "post",
+      body: {
+        formUuid: params.formUuid,
+        formInstId: resolveFormInstanceId(params)
+      }
+    }),
+    getChangeRecords: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/getFormDataChangeRecords.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        formInstId: resolveFormInstanceId(params),
+        page: params.page,
+        pageSize: params.pageSize
+      }
+    }),
+    search: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/searchFormDatas.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        searchFieldJson: serializeSearchExpression(params.search),
+        currentPage: params.currentPage,
+        pageSize: params.pageSize,
+        originatorId: params.originatorId,
+        createFrom: params.createFrom,
+        createTo: params.createTo,
+        modifiedFrom: params.modifiedFrom,
+        modifiedTo: params.modifiedTo,
+        dynamicOrder: normalizeDynamicOrder(params.dynamicOrder),
+        instanceStatus: params.instanceStatus
+      }
+    }),
+    searchIds: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/searchFormDataIds.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        searchFieldJson: serializeSearchExpression(params.search),
+        currentPage: params.currentPage,
+        pageSize: params.pageSize,
+        originatorId: params.originatorId,
+        createFrom: params.createFrom,
+        createTo: params.createTo,
+        modifiedFrom: params.modifiedFrom,
+        modifiedTo: params.modifiedTo,
+        dynamicOrder: normalizeDynamicOrder(params.dynamicOrder),
+        instanceStatus: params.instanceStatus
+      }
+    }),
+    advancedSearch: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/advancedSearch.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        filters: serializeSearchExpression(params.filters),
+        conditionType: params.conditionType,
+        searchKeyWord: params.searchKeyWord,
+        currentPage: params.currentPage,
+        pageSize: params.pageSize,
+        order: normalizeAdvancedOrder(params.order),
+        instanceStatus: params.instanceStatus
+      }
+    }),
+    advancedExport: (params) => download({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/advancedExport.xlsx"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        filters: serializeSearchExpression(params.filters),
+        conditionType: params.conditionType,
+        searchKeyWord: params.searchKeyWord,
+        currentPage: params.currentPage,
+        pageSize: params.pageSize,
+        order: normalizeAdvancedOrder(params.order),
+        instanceStatus: params.instanceStatus,
+        exportAll: params.exportAll,
+        embedImages: params.embedImages,
+        exportFields: params.exportFields?.join(",")
+      }
+    }),
+    downloadImportTemplate: (params) => download({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/advancedExportTemplate.xlsx"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid
+      }
+    }),
+    importPreview: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/importPreview.xlsx"
+      ),
+      method: "post",
+      body: {
+        formUuid: params.formUuid,
+        fileBase64: params.fileBase64,
+        fileName: params.fileName
+      }
+    }),
+    importExcel: (params) => request({
+      path: buildAppPath(context, params.appType, "/v1/form/import.xlsx"),
+      method: "post",
+      body: {
+        formUuid: params.formUuid,
+        fileBase64: params.fileBase64,
+        fileName: params.fileName
+      }
+    }),
+    getImportRecords: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/importRecords.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        currentPage: params.currentPage,
+        pageSize: params.pageSize
+      }
+    }),
+    getExportRecords: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/exportRecords.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid,
+        currentPage: params.currentPage,
+        pageSize: params.pageSize
+      }
+    }),
+    downloadImportSource: (params) => download({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/importRecord/downloadSource.xlsx"
+      ),
+      method: "get",
+      query: {
+        recordId: params.recordId
+      }
+    }),
+    downloadImportFailed: (params) => download({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/importRecord/downloadFailed.xlsx"
+      ),
+      method: "get",
+      query: {
+        recordId: params.recordId
+      }
+    }),
+    downloadExportRecord: (params) => download({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/exportRecord/download.xlsx"
+      ),
+      method: "get",
+      query: {
+        recordId: params.recordId
+      }
+    }),
+    getDataManagementConfig: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/dataManagement/config/get.json"
+      ),
+      method: "get",
+      query: {
+        formUuid: params.formUuid
+      }
+    }),
+    saveDataManagementConfig: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/form/dataManagement/config/save.json"
+      ),
+      method: "post",
+      body: {
+        formUuid: params.formUuid,
+        config: params.config
+      }
+    })
+  };
+  const user = {
+    create: (params) => request({
+      path: "/user/create",
+      method: "post",
+      body: params
+    }),
+    update: (params) => request({
+      path: "/user/update",
+      method: "put",
+      body: params
+    }),
+    remove: (id) => request({
+      path: `/user/${encodePathSegment(id)}`,
+      method: "delete"
+    }),
+    get: (id = "current") => request({
+      path: `/user/${encodePathSegment(id)}`,
+      method: "get"
+    }),
+    getCurrent: () => request({
+      path: "/user/current",
+      method: "get"
+    }),
+    getByUsername: (username) => request({
+      path: `/user/username/${encodePathSegment(username)}`,
+      method: "get"
+    }),
+    list: (params) => request({
+      path: "/user/list",
+      method: "get",
+      query: {
+        ids: params?.ids,
+        departmentIds: params?.departmentIds,
+        name: params?.name,
+        username: params?.username,
+        phone: params?.phone,
+        email: params?.email,
+        page: params?.page,
+        pageSize: params?.pageSize
+      }
+    }),
+    search: (keyword) => request({
+      path: "/user/search",
+      method: "get",
+      query: {
+        keyword
+      }
+    }),
+    listAll: () => request({
+      path: "/user/all",
+      method: "get"
+    }),
+    listByDepartment: (departmentId) => request({
+      path: `/user/department/${encodePathSegment(departmentId)}`,
+      method: "get"
+    }),
+    validate: (params) => request({
+      path: "/user/validate",
+      method: "post",
+      body: params
+    })
+  };
+  const getParentDepartments = (departmentId, options = {}) => request({
+    path: `/department/${encodePathSegment(departmentId)}/parentDepartments`,
+    method: "get",
+    query: {
+      includeSelf: options.includeSelf ?? true
+    }
+  });
+  const department = {
+    getParentDepartments,
+    getCurrentUserParentDepartments: async (options = {}) => {
+      const departments = (context.user.departments || []).filter(
+        (item) => typeof item.id === "string" && item.id.trim()
+      );
+      return Promise.all(
+        departments.map(async (item) => {
+          const response = await getParentDepartments(item.id || "", {
+            includeSelf: options.includeSelf
+          });
+          return {
+            department: item,
+            parents: response.result || []
+          };
+        })
+      );
+    }
+  };
+  const role = {
+    create: (params) => request({
+      path: "/role/",
+      method: "post",
+      body: params
+    }),
+    update: (id, params) => request({
+      path: `/role/${encodePathSegment(id)}`,
+      method: "put",
+      body: params
+    }),
+    remove: (id) => request({
+      path: `/role/${encodePathSegment(id)}`,
+      method: "delete"
+    }),
+    get: (id) => request({
+      path: `/role/${encodePathSegment(id)}`,
+      method: "get"
+    }),
+    list: (params) => request({
+      path: "/role/",
+      method: "get",
+      query: withDefaultAppType(context, params)
+    }),
+    listUsers: (roleId, params) => request({
+      path: `/role/${encodePathSegment(roleId)}/users`,
+      method: "get",
+      query: params
+    }),
+    assignRoles: (params) => request({
+      path: "/role/assign",
+      method: "post",
+      body: params
+    }),
+    addUserRole: (params) => request({
+      path: "/role/add",
+      method: "post",
+      body: params
+    }),
+    removeUserRole: (params) => request({
+      path: "/role/remove",
+      method: "post",
+      body: params
+    }),
+    batchAddUsers: (params) => request({
+      path: "/role/batch-add-users",
+      method: "post",
+      body: params
+    }),
+    getMyRoles: (params) => request({
+      path: "/role/my/roles",
+      method: "get",
+      query: withDefaultAppType(context, params)
+    }),
+    getCurrentRole: (params) => request({
+      path: "/role/my/current",
+      method: "get",
+      query: withDefaultAppType(context, params)
+    }),
+    switchPlatformRole: (params) => request({
+      path: "/role/switch/platform",
+      method: "post",
+      body: params
+    }),
+    switchAppRole: (params) => request({
+      path: "/role/switch/app",
+      method: "post",
+      body: {
+        ...params,
+        appType: resolveAppType(context, params.appType)
+      }
+    })
+  };
+  const permission = {
+    formGroup: {
+      create: (params) => request({
+        path: "/permission/form-group/",
+        method: "post",
+        body: {
+          ...params,
+          appType: resolveAppType(context, params.appType)
+        }
+      }),
+      update: (id, params) => request({
+        path: `/permission/form-group/${encodePathSegment(id)}`,
+        method: "put",
+        body: {
+          ...params,
+          ...params.appType ? { appType: resolveAppType(context, params.appType) } : {}
+        }
+      }),
+      remove: (id) => request({
+        path: `/permission/form-group/${encodePathSegment(id)}`,
+        method: "delete"
+      }),
+      get: (id) => request({
+        path: `/permission/form-group/${encodePathSegment(id)}`,
+        method: "get"
+      }),
+      list: (params) => request({
+        path: "/permission/form-group/",
+        method: "get",
+        query: {
+          ...params,
+          appType: resolveAppType(context, params?.appType)
+        }
+      }),
+      getViewFieldPermissions: (params) => request({
+        path: "/permission/form-group/field-permissions",
+        method: "get",
+        query: {
+          appType: resolveAppType(context, params.appType),
+          formUuid: params.formUuid
+        }
+      }),
+      getViewPermissionSummary: (params) => request({
+        path: "/permission/form-group/view-permissions",
+        method: "get",
+        query: {
+          appType: resolveAppType(context, params.appType),
+          formUuid: params.formUuid
+        }
+      })
+    },
+    pageGroup: {
+      create: (params) => request({
+        path: "/permission/page-group/",
+        method: "post",
+        body: {
+          ...params,
+          appType: resolveAppType(context, params.appType)
+        }
+      }),
+      update: (id, params) => request({
+        path: `/permission/page-group/${encodePathSegment(id)}`,
+        method: "put",
+        body: {
+          ...params,
+          ...params.appType ? { appType: resolveAppType(context, params.appType) } : {}
+        }
+      }),
+      remove: (id) => request({
+        path: `/permission/page-group/${encodePathSegment(id)}`,
+        method: "delete"
+      }),
+      get: (id) => request({
+        path: `/permission/page-group/${encodePathSegment(id)}`,
+        method: "get"
+      }),
+      list: (params) => request({
+        path: "/permission/page-group/",
+        method: "get",
+        query: {
+          ...params,
+          appType: resolveAppType(context, params?.appType)
+        }
+      }),
+      getUserMenuPermissions: (appType) => request({
+        path: "/permission/page-group/user-menu-permissions",
+        method: "get",
+        query: {
+          appType: resolveAppType(context, appType)
+        }
+      })
+    },
+    api: {
+      create: (params) => request({
+        path: "/permission/api",
+        method: "post",
+        body: params
+      }),
+      update: (id, params) => request({
+        path: `/permission/api/${encodePathSegment(id)}`,
+        method: "put",
+        body: params
+      }),
+      remove: (id) => request({
+        path: `/permission/api/${encodePathSegment(id)}`,
+        method: "delete"
+      }),
+      list: (params) => request({
+        path: "/permission/api",
+        method: "get",
+        query: withDefaultAppType(context, params)
+      }),
+      assign: (params) => request({
+        path: "/permission/api/assign",
+        method: "post",
+        body: params
+      }),
+      getByRole: (roleId) => request({
+        path: `/permission/api/role/${encodePathSegment(roleId)}`,
+        method: "get"
+      }),
+      getRolesByPermission: (permissionId) => request({
+        path: `/permission/api/${encodePathSegment(permissionId)}/roles`,
+        method: "get"
+      })
+    },
+    ui: {
+      create: (params) => request({
+        path: "/permission/api/ui",
+        method: "post",
+        body: params
+      }),
+      update: (id, params) => request({
+        path: `/permission/api/ui/${encodePathSegment(id)}`,
+        method: "put",
+        body: params
+      }),
+      remove: (id) => request({
+        path: `/permission/api/ui/${encodePathSegment(id)}`,
+        method: "delete"
+      }),
+      list: (params) => request({
+        path: "/permission/api/ui",
+        method: "get",
+        query: withDefaultAppType(context, params)
+      }),
+      assign: (params) => request({
+        path: "/permission/api/ui/assign",
+        method: "post",
+        body: params
+      }),
+      getMyPlatform: () => request({
+        path: "/permission/api/ui/me/platform",
+        method: "get"
+      }),
+      getMyApp: (appType) => request({
+        path: "/permission/api/ui/me/app",
+        method: "get",
+        query: {
+          appType: resolveAppType(context, appType)
+        }
+      })
+    }
+  };
+  const process2 = {
+    getInstance: (params) => request({
+      path: buildAppPath(context, params.appType, "/v1/process/instance"),
+      method: "get",
+      query: {
+        instanceId: params.instanceId
+      }
+    }),
+    terminateInstance: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/process/terminateInstance.json"
+      ),
+      method: "post",
+      body: {
+        processInstanceId: params.processInstanceId,
+        reason: params.reason
+      }
+    }),
+    approveTask: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/process/approveTask.json"
+      ),
+      method: "post",
+      body: {
+        ...params,
+        appType: resolveAppType(context, params.appType)
+      }
+    }),
+    triggerCallbackTask: (params) => request({
+      path: buildAppPath(
+        context,
+        params.appType,
+        "/v1/process/triggerCallback.json"
+      ),
+      method: "post",
+      body: {
+        taskId: params.taskId,
+        payload: params.payload
+      }
+    })
+  };
+  const dataView = {
+    query: (code, params = {}) => {
+      const dataViewCode = String(code || "").trim();
+      if (!dataViewCode) {
+        throw new Error("\u6570\u636E\u89C6\u56FE code \u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      return request({
+        path: buildAppPath(
+          context,
+          params.appType,
+          `/v1/data-views/${encodePathSegment(dataViewCode)}/query.json`
+        ),
+        method: "post",
+        body: {
+          fields: params.fields,
+          filters: serializeSearchExpression(params.filters),
+          conditionType: params.conditionType,
+          searchKeyWord: params.searchKeyWord,
+          currentPage: params.currentPage,
+          pageSize: params.pageSize,
+          order: Array.isArray(params.order) ? params.order : params.order ? [params.order] : void 0
+        }
+      });
+    },
+    stats: (code, params = {}) => {
+      const dataViewCode = String(code || "").trim();
+      if (!dataViewCode) {
+        throw new Error("\u6570\u636E\u89C6\u56FE code \u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      return request({
+        path: buildAppPath(
+          context,
+          params.appType,
+          `/v1/data-views/${encodePathSegment(dataViewCode)}/stats.json`
+        ),
+        method: "post",
+        body: {
+          fields: params.fields,
+          filters: serializeSearchExpression(params.filters),
+          having: serializeSearchExpression(params.having),
+          conditionType: params.conditionType,
+          searchKeyWord: params.searchKeyWord,
+          currentPage: params.currentPage,
+          pageSize: params.pageSize,
+          order: Array.isArray(params.order) ? params.order : params.order ? [params.order] : void 0
+        }
+      });
+    }
+  };
+  const appFunction = {
+    invoke: (code, params = {}) => {
+      const functionCode = String(code || "").trim();
+      if (!functionCode) {
+        throw new Error("\u5E94\u7528\u51FD\u6570 code \u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      return request({
+        path: buildAppPath(
+          context,
+          params.appType,
+          `/v1/functions/${encodePathSegment(functionCode)}/invoke.json`
+        ),
+        method: "post",
+        body: {
+          input: params.input
+        }
+      });
+    }
+  };
+  const notification = {
+    sendByType: (params) => request({
+      path: buildOpenXiangdaAppPath(
+        context,
+        params.appType,
+        "/notifications/send-by-type"
+      ),
+      method: "post",
+      body: {
+        ...params,
+        appType: resolveAppType(context, params.appType)
+      }
+    }),
+    batchSendByType: (params) => request({
+      path: buildOpenXiangdaAppPath(
+        context,
+        params.appType,
+        "/notifications/batch-send-by-type"
+      ),
+      method: "post",
+      body: {
+        ...params,
+        appType: resolveAppType(context, params.appType)
+      }
+    }),
+    findConfig: (notificationType, params = {}) => request({
+      path: buildOpenXiangdaAppPath(
+        context,
+        params.appType,
+        `/notifications/type-configs/${encodePathSegment(notificationType)}`
+      ),
+      method: "get",
+      query: params.formUuid ? { formUuid: params.formUuid } : void 0
+    }),
+    previewTemplate: (params) => request({
+      path: buildOpenXiangdaAppPath(
+        context,
+        params.appType,
+        "/notifications/templates/preview"
+      ),
+      method: "post",
+      body: {
+        ...params,
+        appType: resolveAppType(context, params.appType)
+      }
+    })
+  };
+  const sdk = {
+    context,
+    request,
+    download,
+    transport: {
+      request,
+      download
+    },
+    auth,
+    connector,
+    form,
+    user,
+    department,
+    role,
+    permission,
+    process: process2,
+    notification,
+    dataView,
+    function: appFunction,
+    dataSource: {
+      run: async (name, params = {}) => {
+        const descriptor = (context.page.dataSources || []).find(
+          (item) => item.key === name
+        );
+        if (!descriptor) {
+          throw new Error(`\u672A\u627E\u5230\u6570\u636E\u6E90: ${String(name || "")}`);
+        }
+        const runtimeParams = params;
+        const resolvedFormUuid = String(
+          runtimeParams.formUuid || descriptor.formUuid || ""
+        ).trim();
+        switch (descriptor.type) {
+          case "dataView.query":
+          case "dataView.stats": {
+            const dataViewCode = String(
+              runtimeParams.code || runtimeParams.dataViewCode || descriptor.code || descriptor.dataViewCode || descriptor.viewCode || descriptor.key || ""
+            ).trim();
+            const queryParams = {
+              ...descriptor.params && typeof descriptor.params === "object" ? descriptor.params : {},
+              ...runtimeParams,
+              fields: runtimeParams.fields || descriptor.fields,
+              filters: mergeSearchExpressions(
+                descriptor.defaultFilter,
+                runtimeParams.filters
+              ),
+              having: mergeSearchExpressions(
+                descriptor.defaultHaving || descriptor.having,
+                runtimeParams.having
+              )
+            };
+            delete queryParams.code;
+            delete queryParams.dataViewCode;
+            delete queryParams.viewCode;
+            if (descriptor.type === "dataView.stats") {
+              return dataView.stats(
+                dataViewCode,
+                queryParams
+              );
+            }
+            delete queryParams.having;
+            return dataView.query(
+              dataViewCode,
+              queryParams
+            );
+          }
+          case "form.list":
+            return form.advancedSearch({
+              ...runtimeParams,
+              formUuid: resolvedFormUuid,
+              filters: mergeSearchExpressions(
+                descriptor.defaultFilter,
+                runtimeParams.filters
+              )
+            });
+          case "form.detail":
+            return form.getDetail({
+              ...runtimeParams,
+              formUuid: resolvedFormUuid
+            });
+          case "form.create":
+            return form.create({
+              ...runtimeParams,
+              formUuid: resolvedFormUuid
+            });
+          case "form.update":
+            return form.update({
+              ...runtimeParams,
+              formUuid: resolvedFormUuid
+            });
+          case "form.delete":
+            return form.remove({
+              ...runtimeParams,
+              formUuid: resolvedFormUuid
+            });
+          default:
+            throw new Error(`\u6682\u4E0D\u652F\u6301\u7684\u6570\u636E\u6E90\u7C7B\u578B: ${String(descriptor.type)}`);
+        }
+      }
+    },
+    navigation: context.navigation,
+    ui: context.ui
+  };
+  return sdk;
+};
+
+// packages/sdk/src/runtime/react/provider.tsx
+import { jsx } from "react/jsx-runtime";
+var PageProvider = ({
+  context,
+  children
+}) => {
+  const value = useMemo(
+    () => ({
+      context,
+      sdk: createPageSdk(context)
+    }),
+    [context]
+  );
+  return /* @__PURE__ */ jsx(ReactPageContext.Provider, { value, children });
+};
+
+// packages/sdk/src/styles/antd-theme.ts
+var baseTheme = {
+  hashed: false,
+  token: {
+    colorPrimary: "#1677ff",
+    colorInfo: "#1677ff",
+    colorSuccess: "#52c41a",
+    colorWarning: "#faad14",
+    colorError: "#ff4d4f",
+    colorText: "rgba(0,0,0,0.88)",
+    colorTextSecondary: "rgba(0,0,0,0.65)",
+    colorTextTertiary: "rgba(0,0,0,0.45)",
+    colorTextDisabled: "rgba(0,0,0,0.25)",
+    colorBgContainer: "#ffffff",
+    colorBgLayout: "#f5f5f5",
+    colorBgElevated: "#ffffff",
+    colorBorder: "#d9d9d9",
+    colorBorderSecondary: "#f0f0f0",
+    borderRadius: 6,
+    borderRadiusSM: 4,
+    borderRadiusLG: 8,
+    fontSize: 14,
+    controlHeight: 32
+  },
+  components: {
+    Form: { itemMarginBottom: 16 },
+    Card: { paddingLG: 24 }
+  }
+};
+var antdTheme = {
+  ...baseTheme,
+  cssVar: { prefix: "ant" }
+};
+var legacyAntdTheme = {
+  ...baseTheme,
+  cssVar: { prefix: "sy-ant" }
+};
+
+// packages/sdk/src/runtime/react/createReactPage.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+dayjs3.locale("zh-cn");
+var NAMESPACE_ROOT_CLASS = "sy-app-workspace";
+var RUNTIME_PORTAL_ATTR = "data-sy-runtime-portal";
+var PORTAL_CONTAINER_STACK_GLOBAL = "__OPENXIANGDA_PORTAL_CONTAINER_STACK__";
+var PORTAL_CONTAINER_RESOLVER_GLOBAL = "__OPENXIANGDA_GET_PORTAL_CONTAINER__";
+var MESSAGE_PROXY_GLOBAL = "__OPENXIANGDA_ANTD_MESSAGE_PROXY__";
+var MESSAGE_METHODS = [
+  "open",
+  "success",
+  "info",
+  "warning",
+  "error",
+  "loading",
+  "destroy"
+];
+var createRuntimeRoot = (el) => {
+  return createRoot(el);
+};
+var normalizeCssIsolation = (value) => {
+  if (value === "namespace" || value === "shadow") return value;
+  return "none";
+};
+var usesLegacyCssIsolation = (cssIsolation) => cssIsolation === "namespace" || cssIsolation === "shadow";
+var getRuntimeCssIsolation = (context) => normalizeCssIsolation(context.page?.capabilities?.cssIsolation);
+var getAntdRuntimeOptions = (cssIsolation) => {
+  const legacy = usesLegacyCssIsolation(cssIsolation);
+  return {
+    prefixCls: legacy ? "sy-ant" : "ant",
+    iconPrefixCls: legacy ? "sy-anticon" : "anticon",
+    messagePrefixCls: legacy ? "sy-ant-message" : "ant-message",
+    theme: legacy ? legacyAntdTheme : antdTheme
+  };
+};
+var isShadowRoot = (rootNode) => typeof ShadowRoot !== "undefined" && rootNode instanceof ShadowRoot;
+var getStyleContainer = (el) => {
+  const rootNode = el.getRootNode?.();
+  if (isShadowRoot(rootNode)) {
+    return rootNode;
+  }
+  return document.head;
+};
+var getRuntimeRoot = (el, triggerNode) => {
+  const rootNode = el.getRootNode?.();
+  if (isShadowRoot(rootNode)) return el;
+  const triggerRoot = triggerNode?.closest?.(
+    `.${NAMESPACE_ROOT_CLASS}`
+  );
+  return triggerRoot || el.closest(`.${NAMESPACE_ROOT_CLASS}`) || el.querySelector(`.${NAMESPACE_ROOT_CLASS}`) || el;
+};
+var getRuntimeOverlayContainer = (el, portalContainer) => {
+  const getOverlayRoot = (triggerNode) => {
+    if (portalContainer?.isConnected) return portalContainer;
+    return getRuntimeRoot(el, triggerNode);
+  };
+  return {
+    getPopupContainer: (triggerNode) => {
+      return getOverlayRoot(triggerNode);
+    },
+    getTargetContainer: () => getRuntimeRoot(el)
+  };
+};
+var createAntdConfig = (overlayContainer, cssIsolation) => {
+  const antdOptions = getAntdRuntimeOptions(cssIsolation);
+  return {
+    locale: zhCN,
+    prefixCls: antdOptions.prefixCls,
+    iconPrefixCls: antdOptions.iconPrefixCls,
+    theme: antdOptions.theme,
+    ...usesLegacyCssIsolation(cssIsolation) ? {
+      getPopupContainer: overlayContainer.getPopupContainer,
+      getTargetContainer: overlayContainer.getTargetContainer
+    } : {}
+  };
+};
+var createPortalContainer = (el) => {
+  const rootNode = el.getRootNode?.();
+  const parent = isShadowRoot(rootNode) ? rootNode : el.ownerDocument?.body || document.body;
+  const portalContainer = el.ownerDocument.createElement("div");
+  portalContainer.setAttribute(RUNTIME_PORTAL_ATTR, "");
+  portalContainer.classList.add(NAMESPACE_ROOT_CLASS);
+  parent.appendChild(portalContainer);
+  return portalContainer;
+};
+var getAntdMessageProxyState = () => {
+  const globalScope = globalThis;
+  if (!globalScope[MESSAGE_PROXY_GLOBAL]) {
+    globalScope[MESSAGE_PROXY_GLOBAL] = {
+      apiStack: [],
+      installed: false,
+      originalMethods: {}
+    };
+  }
+  return globalScope[MESSAGE_PROXY_GLOBAL];
+};
+var installAntdMessageProxy = () => {
+  const state = getAntdMessageProxyState();
+  if (state.installed) return state;
+  MESSAGE_METHODS.forEach((method) => {
+    const originalMethod = message[method];
+    if (typeof originalMethod !== "function") return;
+    state.originalMethods[method] = originalMethod.bind(message);
+    message[method] = (...args) => {
+      const api = state.apiStack.at(-1);
+      const apiMethod = api?.[method];
+      if (typeof apiMethod === "function") {
+        return apiMethod(...args);
+      }
+      return state.originalMethods[method]?.(...args);
+    };
+  });
+  state.installed = true;
+  return state;
+};
+var registerAntdMessageApi = (api) => {
+  const state = installAntdMessageProxy();
+  state.apiStack.push(api);
+  return () => {
+    const position = state.apiStack.lastIndexOf(api);
+    if (position >= 0) {
+      state.apiStack.splice(position, 1);
+    }
+  };
+};
+var installRuntimePortalContainer = (el, cssIsolation) => {
+  const globalScope = globalThis;
+  const portalContainer = usesLegacyCssIsolation(cssIsolation) ? createPortalContainer(el) : null;
+  const stack = Array.isArray(globalScope[PORTAL_CONTAINER_STACK_GLOBAL]) ? globalScope[PORTAL_CONTAINER_STACK_GLOBAL] : [];
+  const stackTarget = portalContainer ?? el.ownerDocument?.body ?? document.body;
+  stack.push(stackTarget);
+  globalScope[PORTAL_CONTAINER_STACK_GLOBAL] = stack;
+  globalScope[PORTAL_CONTAINER_RESOLVER_GLOBAL] = () => {
+    for (let index = stack.length - 1; index >= 0; index -= 1) {
+      const candidate = stack[index];
+      if (candidate?.isConnected) {
+        return candidate;
+      }
+    }
+    return document.querySelector(`[${RUNTIME_PORTAL_ATTR}]`) || document.querySelector(`.${NAMESPACE_ROOT_CLASS}`) || document.body;
+  };
+  return {
+    container: portalContainer,
+    release: () => {
+      const position = stack.lastIndexOf(stackTarget);
+      if (position >= 0) {
+        stack.splice(position, 1);
+      }
+      portalContainer?.remove();
+    }
+  };
+};
+var installAntdStaticHolder = (el, portalContainer, cssIsolation) => {
+  installAntdMessageProxy();
+  const antdOptions = getAntdRuntimeOptions(cssIsolation);
+  const getMessageContainer = () => {
+    if (portalContainer?.isConnected) return portalContainer;
+    return usesLegacyCssIsolation(cssIsolation) ? getRuntimeRoot(el) : document.body;
+  };
+  ConfigProvider.config({
+    prefixCls: antdOptions.prefixCls,
+    iconPrefixCls: antdOptions.iconPrefixCls,
+    theme: antdOptions.theme,
+    holderRender: (children) => {
+      if (!el.isConnected) {
+        return /* @__PURE__ */ jsx2(
+          ConfigProvider,
+          {
+            locale: zhCN,
+            prefixCls: antdOptions.prefixCls,
+            iconPrefixCls: antdOptions.iconPrefixCls,
+            theme: antdOptions.theme,
+            children
+          }
+        );
+      }
+      const overlayContainer = getRuntimeOverlayContainer(el, portalContainer);
+      return /* @__PURE__ */ jsx2(StyleProvider, { hashPriority: "high", container: getStyleContainer(el), children: /* @__PURE__ */ jsx2(ConfigProvider, { ...createAntdConfig(overlayContainer, cssIsolation), children }) });
+    }
+  });
+  message.config({
+    prefixCls: antdOptions.messagePrefixCls,
+    getContainer: getMessageContainer
+  });
+};
+var RuntimeMessageBridge = ({ children }) => {
+  const appContext = AntdApp.useApp();
+  React2.useLayoutEffect(() => {
+    return registerAntdMessageApi(
+      appContext.message
+    );
+  }, [appContext.message]);
+  return /* @__PURE__ */ jsx2(Fragment, { children });
+};
+var createReactPage = (AppComponent) => {
+  let root = null;
+  let currentContainer = null;
+  let releasePortalContainer = null;
+  let portalContainer = null;
+  let currentCssIsolation = null;
+  const render = (el, context) => {
+    const cssIsolation = getRuntimeCssIsolation(context);
+    if (usesLegacyCssIsolation(cssIsolation)) {
+      el.classList.add(NAMESPACE_ROOT_CLASS);
+    } else {
+      el.classList.remove(NAMESPACE_ROOT_CLASS);
+    }
+    if (!root || currentContainer !== el || currentCssIsolation !== cssIsolation || usesLegacyCssIsolation(cssIsolation) && !portalContainer?.isConnected) {
+      root?.unmount();
+      releasePortalContainer?.();
+      root = createRuntimeRoot(el);
+      currentContainer = el;
+      currentCssIsolation = cssIsolation;
+      const portalHandle = installRuntimePortalContainer(el, cssIsolation);
+      portalContainer = portalHandle.container;
+      releasePortalContainer = portalHandle.release;
+    }
+    const overlayContainer = getRuntimeOverlayContainer(el, portalContainer);
+    installAntdStaticHolder(el, portalContainer, cssIsolation);
+    const antdConfig = createAntdConfig(overlayContainer, cssIsolation);
+    root.render(
+      /* @__PURE__ */ jsx2(StyleProvider, { hashPriority: "high", container: getStyleContainer(el), children: /* @__PURE__ */ jsx2(ConfigProvider, { ...antdConfig, children: /* @__PURE__ */ jsx2(AntdApp, { children: /* @__PURE__ */ jsx2(RuntimeMessageBridge, { children: /* @__PURE__ */ jsx2(PageProvider, { context, children: /* @__PURE__ */ jsx2(AppComponent, {}) }) }) }) }) })
+    );
+  };
+  return {
+    mount: (el, context) => {
+      render(el, context);
+    },
+    update: (el, context) => {
+      render(el, context);
+    },
+    unmount: () => {
+      root?.unmount();
+      releasePortalContainer?.();
+      root = null;
+      currentContainer = null;
+      releasePortalContainer = null;
+      portalContainer = null;
+      currentCssIsolation = null;
+    }
+  };
+};
+
+// packages/sdk/src/runtime/react/hooks/useCurrentUser.ts
+import { useMemo as useMemo2 } from "react";
+
+// packages/sdk/src/runtime/react/hooks/usePageContext.ts
+var usePageContext = () => {
+  return usePageSdkStore().context;
+};
+
+// packages/sdk/src/runtime/react/hooks/useCurrentUser.ts
+var useCurrentUser = () => {
+  const { user } = usePageContext();
+  return useMemo2(() => {
+    const userType = user.userType === "guest" || user.isGuest ? "guest" : "normal";
+    const isGuest = userType === "guest";
+    return {
+      user: {
+        ...user,
+        isGuest,
+        userType
+      },
+      isGuest,
+      isInternalUser: !isGuest,
+      displayName: user.name || user.username || user.id,
+      primaryDepartment: user.departments?.[0] || null,
+      affiliatedDepartment: user.affiliatedDepartment || null
+    };
+  }, [user]);
+};
+
+// packages/sdk/src/runtime/react/hooks/useDataSource.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// packages/sdk/src/runtime/react/hooks/usePageSdk.ts
+var usePageSdk = () => {
+  return usePageSdkStore().sdk;
+};
+
+// packages/sdk/src/runtime/react/hooks/useDataSource.ts
+var createParamsSignature = (value) => {
+  try {
+    return JSON.stringify(value || {});
+  } catch {
+    return "";
+  }
+};
+var useDataSource = (name, options = {}) => {
+  const sdk = usePageSdk();
+  const { params, immediate = true, transform } = options;
+  const paramsRef = useRef(params);
+  const transformRef = useRef(transform);
+  const paramsSignature = createParamsSignature(params);
+  const [response, setResponse] = useState(
+    null
+  );
+  const [result, setResult] = useState(null);
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  paramsRef.current = params;
+  transformRef.current = transform;
+  const run = useCallback(
+    async (overrideParams) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response2 = await sdk.dataSource.run(
+          name,
+          overrideParams || paramsRef.current || {}
+        );
+        setResponse(response2);
+        setResult(response2.result);
+        const activeTransform = transformRef.current;
+        const nextData = activeTransform ? activeTransform(response2.result, response2) : response2.result ?? null;
+        setData(nextData);
+        return response2;
+      } catch (runtimeError) {
+        const nextError = runtimeError instanceof Error ? runtimeError : new Error(String(runtimeError));
+        setError(nextError);
+        setResponse(null);
+        setResult(null);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [name, sdk.dataSource]
+  );
+  useEffect(() => {
+    if (!immediate) {
+      return;
+    }
+    void run();
+  }, [immediate, paramsSignature, run]);
+  return {
+    response,
+    result,
+    data,
+    loading,
+    error,
+    refresh: run,
+    run,
+    setResponse,
+    setResult,
+    setData
+  };
+};
+
+// packages/sdk/src/runtime/react/hooks/useFormViewPermissions.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo3, useState as useState2 } from "react";
+var EMPTY_SUMMARY = {
+  fieldPermissions: {},
+  operations: []
+};
+var toError = (error) => {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return new Error(error.message);
+  }
+  return new Error(String(error || "\u83B7\u53D6\u67E5\u770B\u6001\u6743\u9650\u5931\u8D25"));
+};
+var useFormViewPermissions = (formUuid, options = {}) => {
+  const sdk = usePageSdk();
+  const [summary, setSummary] = useState2(EMPTY_SUMMARY);
+  const [response, setResponse] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const immediate = options.immediate ?? true;
+  const refresh = useCallback2(async () => {
+    const normalizedFormUuid = String(formUuid || "").trim();
+    if (!normalizedFormUuid) {
+      setSummary(EMPTY_SUMMARY);
+      setResponse(null);
+      return null;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const nextResponse = await sdk.permission.formGroup.getViewPermissionSummary({
+        appType: options.appType,
+        formUuid: normalizedFormUuid
+      });
+      const nextSummary = nextResponse.result || EMPTY_SUMMARY;
+      setResponse(nextResponse);
+      setSummary({
+        fieldPermissions: nextSummary.fieldPermissions || {},
+        operations: nextSummary.operations || []
+      });
+      return nextResponse;
+    } catch (requestError) {
+      const nextError = toError(requestError);
+      setError(nextError);
+      setResponse(null);
+      setSummary(EMPTY_SUMMARY);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, [formUuid, options.appType, sdk]);
+  useEffect2(() => {
+    if (!immediate) {
+      return;
+    }
+    void refresh();
+  }, [immediate, refresh]);
+  const operationSet = useMemo3(
+    () => new Set(summary.operations),
+    [summary.operations]
+  );
+  const can = useCallback2(
+    (operation) => operationSet.has(operation),
+    [operationSet]
+  );
+  const getFieldPermission = useCallback2(
+    (fieldName) => summary.fieldPermissions[fieldName] || null,
+    [summary.fieldPermissions]
+  );
+  return {
+    summary,
+    response,
+    loading,
+    error,
+    refresh,
+    can,
+    getFieldPermission
+  };
+};
+
+// packages/sdk/src/runtime/react/hooks/useMessage.ts
+var useMessage = () => {
+  return usePageContext().ui.message;
+};
+
+// packages/sdk/src/runtime/react/hooks/useModal.ts
+var useModal = () => {
+  return usePageContext().ui.modal;
+};
+
+// packages/sdk/src/runtime/react/hooks/useNavigation.ts
+var useNavigation = () => {
+  return usePageContext().navigation;
+};
+
+// packages/sdk/src/runtime/react/hooks/usePageProps.ts
+var usePageProps = () => {
+  return usePageContext().page.props;
+};
+
+// packages/sdk/src/runtime/react/hooks/usePageRoute.ts
+var usePageRoute = () => {
+  return usePageContext().route;
+};
+
 // packages/sdk/src/runtime/react/openxiangdaProvider.tsx
 import {
-  createContext,
-  useCallback as useCallback2,
-  useContext,
-  useEffect as useEffect2,
-  useMemo as useMemo2,
-  useState as useState2
+  createContext as createContext2,
+  useCallback as useCallback4,
+  useContext as useContext2,
+  useEffect as useEffect4,
+  useMemo as useMemo5,
+  useState as useState4
 } from "react";
 
 // packages/sdk/src/runtime/core/fetch.ts
@@ -16,10 +2467,10 @@ var createBoundFetch = (fetchImpl) => {
 
 // packages/sdk/src/runtime/react/auth.tsx
 import {
-  useCallback,
-  useEffect,
-  useMemo,
-  useState
+  useCallback as useCallback3,
+  useEffect as useEffect3,
+  useMemo as useMemo4,
+  useState as useState3
 } from "react";
 import {
   Alert,
@@ -42,8 +2493,8 @@ import {
 
 // packages/sdk/src/runtime/core/auth.ts
 var AuthClientError = class extends Error {
-  constructor(message, options = {}) {
-    super(message);
+  constructor(message2, options = {}) {
+    super(message2);
     this.name = "AuthClientError";
     this.status = options.status;
     this.code = options.code;
@@ -126,7 +2577,7 @@ var getRecordValue = (value, key) => {
   return value[key];
 };
 var resolveLoginUrl = (appType, {
-  callbackUrl = getCurrentHref(),
+  callbackUrl = getCurrentHref2(),
   callbackParamName = "callback",
   loginUrl
 }) => {
@@ -147,13 +2598,13 @@ var resolveLoginUrl = (appType, {
     return `${target}${separator}${callbackParamName}=${encodeURIComponent(callbackUrl)}`;
   }
 };
-var getCurrentHref = () => typeof window === "undefined" ? "" : window.location.href;
+var getCurrentHref2 = () => typeof window === "undefined" ? "" : window.location.href;
 
 // packages/sdk/src/runtime/react/auth.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 var useAuth = (options = {}) => {
   const runtime = useOpenXiangda();
-  const client = useMemo(
+  const client = useMemo4(
     () => createAuthClient({
       appType: options.appType || runtime.appType,
       servicePrefix: options.servicePrefix || runtime.servicePrefix,
@@ -168,7 +2619,7 @@ var useAuth = (options = {}) => {
       runtime.servicePrefix
     ]
   );
-  return useMemo(
+  return useMemo4(
     () => ({
       client,
       getMethods: client.getMethods,
@@ -188,12 +2639,12 @@ var useAuth = (options = {}) => {
 };
 var useLoginMethods = (options = {}) => {
   const auth = useAuth(options);
-  const [state, setState] = useState({
+  const [state, setState] = useState3({
     data: null,
     loading: true,
     error: null
   });
-  const reload = useCallback(async () => {
+  const reload = useCallback3(async () => {
     setState((prev) => ({ ...prev, loading: true, error: null }));
     try {
       const data = await auth.getMethods();
@@ -206,7 +2657,7 @@ var useLoginMethods = (options = {}) => {
       });
     }
   }, [auth]);
-  useEffect(() => {
+  useEffect3(() => {
     let disposed = false;
     const run = async () => {
       setState((prev) => ({ ...prev, loading: true, error: null }));
@@ -250,16 +2701,16 @@ var LoginPage = ({
   const methodsState = useLoginMethods(authOptions);
   const [passwordForm] = Form.useForm();
   const [phoneForm] = Form.useForm();
-  const [activeMethod, setActiveMethod] = useState(
+  const [activeMethod, setActiveMethod] = useState3(
     defaultMethod || "password"
   );
-  const [phonePurpose, setPhonePurpose] = useState(
+  const [phonePurpose, setPhonePurpose] = useState3(
     "login"
   );
-  const [phoneChallengeId, setPhoneChallengeId] = useState("");
-  const [submitting, setSubmitting] = useState(false);
-  const [sendingCode, setSendingCode] = useState(false);
-  const [error, setError] = useState(null);
+  const [phoneChallengeId, setPhoneChallengeId] = useState3("");
+  const [submitting, setSubmitting] = useState3(false);
+  const [sendingCode, setSendingCode] = useState3(false);
+  const [error, setError] = useState3(null);
   const methods = methodsState.methods.filter((method) => method.enabled !== false);
   const passwordMethod = findMethod(methods, "password");
   const phoneMethod = findMethod(methods, "phone_code");
@@ -267,16 +2718,16 @@ var LoginPage = ({
   const ssoMethod = findMethod(methods, "sso");
   const guestMethod = findMethod(methods, "guest");
   const allowRegister = methodsState.data?.registration?.mode !== "reject";
-  const tabItems = useMemo(() => {
+  const tabItems = useMemo4(() => {
     const items = [];
     if (passwordMethod) {
       items.push({
         key: "password",
         label: /* @__PURE__ */ jsxs(Space, { size: 6, children: [
-          /* @__PURE__ */ jsx(UserOutlined, {}),
-          /* @__PURE__ */ jsx("span", { children: passwordMethod.label || "\u8D26\u53F7\u5BC6\u7801" })
+          /* @__PURE__ */ jsx3(UserOutlined, {}),
+          /* @__PURE__ */ jsx3("span", { children: passwordMethod.label || "\u8D26\u53F7\u5BC6\u7801" })
         ] }),
-        children: /* @__PURE__ */ jsx(
+        children: /* @__PURE__ */ jsx3(
           PasswordLoginForm,
           {
             form: passwordForm,
@@ -305,10 +2756,10 @@ var LoginPage = ({
       items.push({
         key: "phone_code",
         label: /* @__PURE__ */ jsxs(Space, { size: 6, children: [
-          /* @__PURE__ */ jsx(MobileOutlined, {}),
-          /* @__PURE__ */ jsx("span", { children: phoneMethod.label || "\u624B\u673A\u53F7" })
+          /* @__PURE__ */ jsx3(MobileOutlined, {}),
+          /* @__PURE__ */ jsx3("span", { children: phoneMethod.label || "\u624B\u673A\u53F7" })
         ] }),
-        children: /* @__PURE__ */ jsx(
+        children: /* @__PURE__ */ jsx3(
           PhoneCodeLoginForm,
           {
             allowRegister,
@@ -371,7 +2822,7 @@ var LoginPage = ({
     sendingCode,
     submitting
   ]);
-  useEffect(() => {
+  useEffect3(() => {
     const firstKey = tabItems[0]?.key;
     if (firstKey && !tabItems.some((item) => item.key === activeMethod)) {
       setActiveMethod(firstKey);
@@ -398,7 +2849,7 @@ var LoginPage = ({
     setSubmitting(true);
     setError(null);
     try {
-      const redirectUri = getCurrentHref2();
+      const redirectUri = getCurrentHref3();
       const result = await auth.getSsoLoginUrl({
         protocol: getString(ssoMethod, "protocol") || "cas",
         redirectUri
@@ -434,7 +2885,7 @@ var LoginPage = ({
       );
     }
   }
-  return /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx3(
     "div",
     {
       className,
@@ -446,7 +2897,7 @@ var LoginPage = ({
         background: "#f6f8fb",
         ...style
       },
-      children: /* @__PURE__ */ jsx(
+      children: /* @__PURE__ */ jsx3(
         Card,
         {
           style: {
@@ -457,10 +2908,10 @@ var LoginPage = ({
           styles: { body: { padding: 28 } },
           children: /* @__PURE__ */ jsxs(Space, { direction: "vertical", size: 20, style: { width: "100%" }, children: [
             /* @__PURE__ */ jsxs("div", { children: [
-              /* @__PURE__ */ jsx(Typography.Title, { level: 3, style: { margin: 0 }, children: title || "\u5E94\u7528\u767B\u5F55" }),
-              subtitle ? /* @__PURE__ */ jsx(Typography.Text, { type: "secondary", children: subtitle }) : null
+              /* @__PURE__ */ jsx3(Typography.Title, { level: 3, style: { margin: 0 }, children: title || "\u5E94\u7528\u767B\u5F55" }),
+              subtitle ? /* @__PURE__ */ jsx3(Typography.Text, { type: "secondary", children: subtitle }) : null
             ] }),
-            methodsState.error ? /* @__PURE__ */ jsx(
+            methodsState.error ? /* @__PURE__ */ jsx3(
               Alert,
               {
                 showIcon: true,
@@ -468,41 +2919,41 @@ var LoginPage = ({
                 message: methodsState.error.message
               }
             ) : null,
-            error ? /* @__PURE__ */ jsx(Alert, { showIcon: true, type: "error", message: error }) : null,
-            methodsState.loading ? /* @__PURE__ */ jsx(Button, { block: true, loading: true, children: "\u52A0\u8F7D\u4E2D" }) : tabItems.length > 0 ? /* @__PURE__ */ jsx(
+            error ? /* @__PURE__ */ jsx3(Alert, { showIcon: true, type: "error", message: error }) : null,
+            methodsState.loading ? /* @__PURE__ */ jsx3(Button, { block: true, loading: true, children: "\u52A0\u8F7D\u4E2D" }) : tabItems.length > 0 ? /* @__PURE__ */ jsx3(
               Tabs,
               {
                 activeKey: activeMethod,
                 items: tabItems,
                 onChange: setActiveMethod
               }
-            ) : /* @__PURE__ */ jsx(Empty, { description: "\u672A\u542F\u7528\u767B\u5F55\u65B9\u5F0F" }),
+            ) : /* @__PURE__ */ jsx3(Empty, { description: "\u672A\u542F\u7528\u767B\u5F55\u65B9\u5F0F" }),
             /* @__PURE__ */ jsxs(Space, { direction: "vertical", size: 10, style: { width: "100%" }, children: [
-              dingtalkMethod ? /* @__PURE__ */ jsx(
+              dingtalkMethod ? /* @__PURE__ */ jsx3(
                 Button,
                 {
                   block: true,
-                  icon: /* @__PURE__ */ jsx(QrcodeOutlined, {}),
+                  icon: /* @__PURE__ */ jsx3(QrcodeOutlined, {}),
                   loading: submitting,
                   onClick: handleDingTalkLogin,
                   children: dingtalkMethod.label || "\u9489\u9489\u514D\u767B"
                 }
               ) : null,
-              ssoMethod ? /* @__PURE__ */ jsx(
+              ssoMethod ? /* @__PURE__ */ jsx3(
                 Button,
                 {
                   block: true,
-                  icon: /* @__PURE__ */ jsx(SafetyCertificateOutlined, {}),
+                  icon: /* @__PURE__ */ jsx3(SafetyCertificateOutlined, {}),
                   loading: submitting,
                   onClick: handleSsoLogin,
                   children: ssoMethod.label || "SSO \u767B\u5F55"
                 }
               ) : null,
-              guestMethod ? /* @__PURE__ */ jsx(
+              guestMethod ? /* @__PURE__ */ jsx3(
                 Button,
                 {
                   block: true,
-                  icon: /* @__PURE__ */ jsx(LoginOutlined, {}),
+                  icon: /* @__PURE__ */ jsx3(LoginOutlined, {}),
                   loading: submitting,
                   onClick: handleGuestLogin,
                   children: guestMethod.label || "\u8BBF\u5BA2\u8BBF\u95EE"
@@ -516,25 +2967,25 @@ var LoginPage = ({
   );
 };
 var PasswordLoginForm = ({ form, loading, onFinish }) => /* @__PURE__ */ jsxs(Form, { form, layout: "vertical", requiredMark: false, onFinish, children: [
-  /* @__PURE__ */ jsx(
+  /* @__PURE__ */ jsx3(
     Form.Item,
     {
       label: "\u8D26\u53F7",
       name: "username",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u8D26\u53F7" }],
-      children: /* @__PURE__ */ jsx(Input, { autoComplete: "username" })
+      children: /* @__PURE__ */ jsx3(Input, { autoComplete: "username" })
     }
   ),
-  /* @__PURE__ */ jsx(
+  /* @__PURE__ */ jsx3(
     Form.Item,
     {
       label: "\u5BC6\u7801",
       name: "password",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u5BC6\u7801" }],
-      children: /* @__PURE__ */ jsx(Input.Password, { autoComplete: "current-password" })
+      children: /* @__PURE__ */ jsx3(Input.Password, { autoComplete: "current-password" })
     }
   ),
-  /* @__PURE__ */ jsx(Button, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx(LoginOutlined, {}), loading, type: "primary", children: "\u767B\u5F55" })
+  /* @__PURE__ */ jsx3(Button, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx3(LoginOutlined, {}), loading, type: "primary", children: "\u767B\u5F55" })
 ] });
 var PhoneCodeLoginForm = ({
   allowRegister,
@@ -546,7 +2997,7 @@ var PhoneCodeLoginForm = ({
   onSendCode,
   onFinish
 }) => /* @__PURE__ */ jsxs(Form, { form, layout: "vertical", requiredMark: false, onFinish, children: [
-  allowRegister ? /* @__PURE__ */ jsx(Form.Item, { style: { marginBottom: 12 }, children: /* @__PURE__ */ jsx(
+  allowRegister ? /* @__PURE__ */ jsx3(Form.Item, { style: { marginBottom: 12 }, children: /* @__PURE__ */ jsx3(
     Tabs,
     {
       activeKey: phonePurpose,
@@ -558,25 +3009,25 @@ var PhoneCodeLoginForm = ({
       size: "small"
     }
   ) }) : null,
-  /* @__PURE__ */ jsx(
+  /* @__PURE__ */ jsx3(
     Form.Item,
     {
       label: "\u624B\u673A\u53F7",
       name: "phone",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u624B\u673A\u53F7" }],
-      children: /* @__PURE__ */ jsx(Input, { autoComplete: "tel" })
+      children: /* @__PURE__ */ jsx3(Input, { autoComplete: "tel" })
     }
   ),
-  /* @__PURE__ */ jsx(
+  /* @__PURE__ */ jsx3(
     Form.Item,
     {
       label: "\u9A8C\u8BC1\u7801",
       name: "code",
       rules: [{ required: true, message: "\u8BF7\u8F93\u5165\u9A8C\u8BC1\u7801" }],
-      children: /* @__PURE__ */ jsx(
+      children: /* @__PURE__ */ jsx3(
         Input,
         {
-          addonAfter: /* @__PURE__ */ jsx(
+          addonAfter: /* @__PURE__ */ jsx3(
             Button,
             {
               loading: sendingCode,
@@ -591,7 +3042,7 @@ var PhoneCodeLoginForm = ({
       )
     }
   ),
-  /* @__PURE__ */ jsx(Button, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx(MobileOutlined, {}), loading, type: "primary", children: phonePurpose === "register" ? "\u6CE8\u518C" : "\u767B\u5F55" })
+  /* @__PURE__ */ jsx3(Button, { block: true, htmlType: "submit", icon: /* @__PURE__ */ jsx3(MobileOutlined, {}), loading, type: "primary", children: phonePurpose === "register" ? "\u6CE8\u518C" : "\u767B\u5F55" })
 ] });
 var findMethod = (methods, type) => methods.find((method) => method.type === type);
 var normalizeError = (error) => error instanceof Error ? error : new Error(String(error || "\u8BF7\u6C42\u5931\u8D25"));
@@ -629,7 +3080,7 @@ var getOrCreateGuestIdentifier = (client) => {
   return next;
 };
 var createGuestIdentifier = () => `guest_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-var getCurrentHref2 = () => typeof window === "undefined" ? "" : window.location.href;
+var getCurrentHref3 = () => typeof window === "undefined" ? "" : window.location.href;
 var getCurrentHostname = () => typeof window === "undefined" ? "" : window.location.hostname;
 var getCallbackUrl = () => {
   if (typeof window === "undefined") return "";
@@ -638,7 +3089,7 @@ var getCallbackUrl = () => {
 };
 
 // packages/sdk/src/runtime/react/openxiangdaProvider.tsx
-import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx4 } from "react/jsx-runtime";
 var RuntimeHttpError = class extends Error {
   constructor(snapshot) {
     super(snapshot.message);
@@ -649,24 +3100,24 @@ var RuntimeHttpError = class extends Error {
     this.payload = snapshot.payload;
   }
 };
-var OpenXiangdaRuntimeContext = createContext(null);
+var OpenXiangdaRuntimeContext = createContext2(null);
 var OpenXiangdaProvider = ({
   appType,
   servicePrefix = "/service",
   fetchImpl,
   children
 }) => {
-  const resolvedFetch = useMemo2(() => createBoundFetch(fetchImpl), [fetchImpl]);
-  const resolvedAppType = useMemo2(
+  const resolvedFetch = useMemo5(() => createBoundFetch(fetchImpl), [fetchImpl]);
+  const resolvedAppType = useMemo5(
     () => appType || resolveAppTypeFromLocation(),
     [appType]
   );
-  const [state, setState] = useState2({
+  const [state, setState] = useState4({
     data: null,
     loading: true,
     error: null
   });
-  const reload = useCallback2(async () => {
+  const reload = useCallback4(async () => {
     if (!resolvedAppType) {
       setState({
         data: null,
@@ -713,10 +3164,10 @@ var OpenXiangdaProvider = ({
       });
     }
   }, [resolvedAppType, resolvedFetch, servicePrefix]);
-  useEffect2(() => {
+  useEffect4(() => {
     void reload();
   }, [reload]);
-  const value = useMemo2(
+  const value = useMemo5(
     () => ({
       ...state,
       appType: resolvedAppType,
@@ -726,10 +3177,10 @@ var OpenXiangdaProvider = ({
     }),
     [reload, resolvedAppType, resolvedFetch, servicePrefix, state]
   );
-  return /* @__PURE__ */ jsx2(OpenXiangdaRuntimeContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx4(OpenXiangdaRuntimeContext.Provider, { value, children });
 };
 var useOpenXiangda = () => {
-  const context = useContext(OpenXiangdaRuntimeContext);
+  const context = useContext2(OpenXiangdaRuntimeContext);
   if (!context) {
     throw new Error("useOpenXiangda must be used inside OpenXiangdaProvider");
   }
@@ -752,12 +3203,12 @@ var usePermission = () => {
 };
 var useCanAccessRoute = (input) => {
   const runtime = useOpenXiangda();
-  const [state, setState] = useState2({
+  const [state, setState] = useState4({
     data: null,
     loading: true,
     error: null
   });
-  useEffect2(() => {
+  useEffect4(() => {
     let disposed = false;
     const check = async () => {
       const permissions = runtime.data?.permissions;
@@ -879,18 +3330,18 @@ var PermissionBoundary = ({
   const access = useCanAccessRoute({ routeCode, menuCode, path });
   const fallbackState = createPermissionFallbackState(access, runtime);
   if (access.loading) {
-    return /* @__PURE__ */ jsx2(Fragment, { children: renderBoundaryFallback(loadingFallback, fallbackState) });
+    return /* @__PURE__ */ jsx4(Fragment2, { children: renderBoundaryFallback(loadingFallback, fallbackState) });
   }
   if (!access.canAccess) {
-    return /* @__PURE__ */ jsx2(Fragment, { children: renderBoundaryFallback(fallback, fallbackState) });
+    return /* @__PURE__ */ jsx4(Fragment2, { children: renderBoundaryFallback(fallback, fallbackState) });
   }
-  return /* @__PURE__ */ jsx2(Fragment, { children });
+  return /* @__PURE__ */ jsx4(Fragment2, { children });
 };
 var useRuntimeAuth = () => {
   const runtime = useOpenXiangda();
-  const resolveLoginUrl2 = useCallback2(
+  const resolveLoginUrl2 = useCallback4(
     async (options = {}) => {
-      const redirectUri = options.redirectUri || getCurrentHref3();
+      const redirectUri = options.redirectUri || getCurrentHref4();
       const domain = options.domain || getCurrentHostname2();
       const appTenantId = getRecordString(runtime.data?.app, "tenantId");
       try {
@@ -935,7 +3386,7 @@ var useRuntimeAuth = () => {
     },
     [runtime.data?.app, runtime.fetchImpl, runtime.servicePrefix]
   );
-  const redirectToLogin = useCallback2(
+  const redirectToLogin = useCallback4(
     async (options = {}) => {
       const loginUrl = await resolveLoginUrl2(options);
       if (typeof window !== "undefined") {
@@ -949,7 +3400,7 @@ var useRuntimeAuth = () => {
     },
     [resolveLoginUrl2]
   );
-  const logout = useCallback2(async () => {
+  const logout = useCallback4(async () => {
     const response = await runtime.fetchImpl(
       buildServiceUrl2(runtime.servicePrefix, "/api/auth/logout"),
       {
@@ -968,7 +3419,7 @@ var useRuntimeAuth = () => {
     }
     return payload;
   }, [runtime.fetchImpl, runtime.servicePrefix]);
-  const logoutAndRedirect = useCallback2(
+  const logoutAndRedirect = useCallback4(
     async (options = {}) => {
       try {
         await logout();
@@ -1081,7 +3532,7 @@ var attachCallback = (loginUrl, callback) => {
     return `${loginUrl}${separator}callback=${encodeURIComponent(callback)}`;
   }
 };
-var getCurrentHref3 = () => typeof window === "undefined" ? "" : window.location.href;
+var getCurrentHref4 = () => typeof window === "undefined" ? "" : window.location.href;
 var getCurrentHostname2 = () => typeof window === "undefined" ? "" : window.location.hostname;
 var getRuntimeEnv = (key) => {
   const env = typeof process !== "undefined" ? process.env : void 0;
@@ -1103,19 +3554,233 @@ var resolveAppTypeFromLocation = () => {
   if (segments[viewIndex] === "preview") return segments[viewIndex + 1] || "";
   return segments[viewIndex] || "";
 };
+
+// packages/sdk/src/runtime/react/publicAccess.tsx
+import { useCallback as useCallback5, useEffect as useEffect5, useMemo as useMemo6, useState as useState5 } from "react";
+
+// packages/sdk/src/runtime/core/publicAccess.ts
+var PublicAccessClientError = class extends Error {
+  constructor(message2, options = {}) {
+    super(message2);
+    this.name = "PublicAccessClientError";
+    this.status = options.status;
+    this.code = options.code;
+    this.payload = options.payload;
+  }
+};
+var createPublicAccessClient = ({
+  appType,
+  servicePrefix = "/service",
+  fetchImpl
+}) => {
+  const normalizedAppType = String(appType || "").trim();
+  if (!normalizedAppType) {
+    throw new Error("appType \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const boundFetch = createBoundFetch(fetchImpl);
+  const request = async (input = {}) => {
+    const body = {
+      ...input,
+      path: input.path || getCurrentPathname(),
+      domain: input.domain || getCurrentDomain(),
+      userAgent: input.userAgent || getCurrentUserAgent(),
+      guestIdentifier: input.guestIdentifier || getOrCreatePublicGuestIdentifier(normalizedAppType)
+    };
+    const response = await boundFetch(
+      buildServiceUrl3(
+        servicePrefix,
+        `/openxiangda-api/v1/apps/${encodeURIComponent(
+          normalizedAppType
+        )}/public/session`
+      ),
+      {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          accept: "application/json",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    const payload = await readPayload2(response);
+    const code = getRecordValue3(payload, "code");
+    if (!response.ok || typeof code === "number" && code >= 400) {
+      throw new PublicAccessClientError(
+        String(
+          getRecordValue3(payload, "message") || `Public access session failed: ${response.status}`
+        ),
+        { status: response.status, code, payload }
+      );
+    }
+    const data = getRecordValue3(payload, "data");
+    const extra = getRecordValue3(payload, "extra");
+    return {
+      ...data,
+      publicAccess: extra?.publicAccess || null,
+      raw: payload
+    };
+  };
+  return {
+    appType: normalizedAppType,
+    servicePrefix,
+    startSession: request
+  };
+};
+var buildServiceUrl3 = (servicePrefix, path) => {
+  const prefix = servicePrefix.endsWith("/") ? servicePrefix.slice(0, -1) : servicePrefix;
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  return `${prefix}${suffix}`;
+};
+var readPayload2 = async (response) => {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+};
+var getRecordValue3 = (value, key) => {
+  if (!value || typeof value !== "object") return void 0;
+  return value[key];
+};
+var getCurrentPathname = () => typeof window === "undefined" ? void 0 : window.location.pathname;
+var getCurrentDomain = () => typeof window === "undefined" ? void 0 : window.location.host;
+var getCurrentUserAgent = () => typeof navigator === "undefined" ? void 0 : navigator.userAgent;
+var getOrCreatePublicGuestIdentifier = (appType) => {
+  const key = `openxiangda:public:guest:${appType}`;
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      const existing = window.localStorage.getItem(key);
+      if (existing) return existing;
+      const next = createRandomIdentifier(appType);
+      window.localStorage.setItem(key, next);
+      return next;
+    }
+  } catch {
+  }
+  return createRandomIdentifier(appType);
+};
+var createRandomIdentifier = (appType) => {
+  const random = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : Math.random().toString(36).slice(2);
+  return `public:${appType}:${random}`;
+};
+
+// packages/sdk/src/runtime/react/publicAccess.tsx
+import { Fragment as Fragment3, jsx as jsx5 } from "react/jsx-runtime";
+var usePublicAccess = (options = {}) => {
+  const runtime = useOpenXiangda();
+  const {
+    appType: runtimeAppType,
+    servicePrefix: runtimeServicePrefix,
+    fetchImpl: runtimeFetchImpl,
+    reload: reloadRuntime
+  } = runtime;
+  const {
+    appType = runtimeAppType,
+    servicePrefix = runtimeServicePrefix,
+    fetchImpl = runtimeFetchImpl,
+    autoStart = true,
+    ...sessionInput
+  } = options;
+  const [session, setSession] = useState5(null);
+  const [error, setError] = useState5(null);
+  const [loading, setLoading] = useState5(Boolean(autoStart));
+  const sessionInputKey = JSON.stringify(sessionInput);
+  const stableSessionInput = useMemo6(() => sessionInput, [sessionInputKey]);
+  const client = useMemo6(
+    () => createPublicAccessClient({
+      appType,
+      servicePrefix,
+      fetchImpl
+    }),
+    [appType, fetchImpl, servicePrefix]
+  );
+  const startSession = useCallback5(
+    async (input = {}) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const data = await client.startSession({
+          ...stableSessionInput,
+          ...input,
+          ticket: input.ticket || stableSessionInput.ticket || readTicketFromLocation(),
+          path: input.path || stableSessionInput.path || readPathFromLocation()
+        });
+        setSession(data);
+        await reloadRuntime();
+        setLoading(false);
+        return data;
+      } catch (caught) {
+        const nextError = caught instanceof PublicAccessClientError ? caught : new PublicAccessClientError(
+          caught instanceof Error ? caught.message : "\u516C\u5F00\u8BBF\u95EE\u4F1A\u8BDD\u521B\u5EFA\u5931\u8D25",
+          { payload: caught }
+        );
+        setError(nextError);
+        setLoading(false);
+        throw nextError;
+      }
+    },
+    [client, reloadRuntime, stableSessionInput]
+  );
+  useEffect5(() => {
+    if (!autoStart) return;
+    void startSession().catch(() => void 0);
+  }, [autoStart, startSession]);
+  return {
+    loading,
+    error,
+    session,
+    publicAccess: session?.publicAccess || null,
+    startSession
+  };
+};
+var PublicAccessGate = ({
+  children,
+  fallback = null,
+  errorFallback = null,
+  ...options
+}) => {
+  const state = usePublicAccess(options);
+  if (state.loading) return /* @__PURE__ */ jsx5(Fragment3, { children: fallback });
+  if (state.error) {
+    return /* @__PURE__ */ jsx5(Fragment3, { children: typeof errorFallback === "function" ? errorFallback(state.error) : errorFallback });
+  }
+  return /* @__PURE__ */ jsx5(Fragment3, { children });
+};
+var readTicketFromLocation = () => {
+  if (typeof window === "undefined") return void 0;
+  return new URLSearchParams(window.location.search).get("ticket") || void 0;
+};
+var readPathFromLocation = () => typeof window === "undefined" ? void 0 : window.location.pathname;
 export {
   AuthClientError,
   LoginPage,
   OpenXiangdaProvider,
+  PageProvider,
   PermissionBoundary,
-  RuntimeHttpError,
+  PublicAccessClientError,
+  PublicAccessGate,
   createAuthClient,
+  createPageSdk,
+  createPublicAccessClient,
+  createReactPage,
   useAppMenus,
   useAuth,
   useCanAccessRoute,
+  useCurrentUser,
+  useDataSource,
+  useFormViewPermissions,
   useLoginMethods,
+  useMessage,
+  useModal,
+  useNavigation,
   useOpenXiangda,
+  usePageContext,
+  usePageProps,
+  usePageRoute,
+  usePageSdk,
   usePermission,
+  usePublicAccess,
   useRuntimeAuth,
   useRuntimeBootstrap
 };