openxiangda 1.0.0

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

@@ -0,0 +1,1420 @@
+// 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 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 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 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 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 process = {
+    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 notification = {
+    sendByType: (params) => request({
+      path: "/api/notification-config/send-by-type",
+      method: "post",
+      body: {
+        ...params,
+        appType: resolveAppType(context, params.appType)
+      }
+    }),
+    batchSendByType: (params) => request({
+      path: "/api/notification-config/batch-send-by-type",
+      method: "post",
+      body: {
+        ...params,
+        appType: resolveAppType(context, params.appType)
+      }
+    })
+  };
+  const sdk = {
+    context,
+    request,
+    download,
+    transport: {
+      request,
+      download
+    },
+    form,
+    user,
+    department,
+    role,
+    permission,
+    process,
+    notification,
+    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 "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/createReactPage.tsx
+import { StyleProvider } from "@ant-design/cssinjs";
+import { App as AntdApp, ConfigProvider } from "antd";
+import zhCN from "antd/locale/zh_CN.js";
+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/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 antdTheme = {
+  cssVar: { prefix: "sy-ant" },
+  hashed: false,
+  token: {
+    colorPrimary: "var(--sy-color-primary)",
+    colorSuccess: "var(--sy-color-success)",
+    colorWarning: "var(--sy-color-warning)",
+    colorError: "var(--sy-color-error)",
+    colorText: "var(--sy-color-text)",
+    colorTextSecondary: "var(--sy-color-text-secondary)",
+    colorTextTertiary: "var(--sy-color-text-tertiary)",
+    colorTextDisabled: "var(--sy-color-text-disabled)",
+    colorBgContainer: "var(--sy-color-bg-container)",
+    colorBgLayout: "var(--sy-color-bg-layout)",
+    colorBgElevated: "var(--sy-color-bg-elevated)",
+    colorBorder: "var(--sy-color-border)",
+    colorBorderSecondary: "var(--sy-color-border-secondary)",
+    borderRadius: 6,
+    borderRadiusSM: 4,
+    borderRadiusLG: 8,
+    fontSize: 14,
+    controlHeight: 32
+  },
+  components: {
+    Form: { itemMarginBottom: 16 },
+    Card: { paddingLG: 24 }
+  }
+};
+
+// packages/sdk/src/runtime/react/createReactPage.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var createRuntimeRoot = (el) => {
+  return createRoot(el);
+};
+var getStyleContainer = (el) => {
+  const rootNode = el.getRootNode?.();
+  if (typeof ShadowRoot !== "undefined" && rootNode instanceof ShadowRoot) {
+    return rootNode;
+  }
+  return document.head;
+};
+var getRuntimeOverlayContainer = (el) => {
+  const rootNode = el.getRootNode?.();
+  const isShadowRoot = typeof ShadowRoot !== "undefined" && rootNode instanceof ShadowRoot;
+  const namespaceRoot = el.closest(".sy-app-workspace");
+  return {
+    getPopupContainer: (triggerNode) => {
+      if (isShadowRoot) return el;
+      return namespaceRoot || triggerNode?.parentElement || document.body;
+    },
+    getTargetContainer: () => isShadowRoot ? el : namespaceRoot || el.ownerDocument?.body || document.body
+  };
+};
+var createReactPage = (AppComponent) => {
+  let root = null;
+  let currentContainer = null;
+  const render = (el, context) => {
+    const rootNode = el.getRootNode?.();
+    if (!(typeof ShadowRoot !== "undefined" && rootNode instanceof ShadowRoot)) {
+      el.classList.add("sy-app-workspace");
+    }
+    if (!root || currentContainer !== el) {
+      root?.unmount();
+      root = createRuntimeRoot(el);
+      currentContainer = el;
+    }
+    const overlayContainer = getRuntimeOverlayContainer(el);
+    root.render(
+      /* @__PURE__ */ jsx2(StyleProvider, { hashPriority: "high", container: getStyleContainer(el), children: /* @__PURE__ */ jsx2(
+        ConfigProvider,
+        {
+          locale: zhCN,
+          prefixCls: "sy-ant",
+          iconPrefixCls: "sy-anticon",
+          theme: antdTheme,
+          getPopupContainer: overlayContainer.getPopupContainer,
+          getTargetContainer: overlayContainer.getTargetContainer,
+          children: /* @__PURE__ */ jsx2(AntdApp, { 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();
+      root = null;
+      currentContainer = 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
+    };
+  }, [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;
+};
+export {
+  PageProvider,
+  createPageSdk,
+  createReactPage,
+  useCurrentUser,
+  useDataSource,
+  useFormViewPermissions,
+  useMessage,
+  useModal,
+  useNavigation,
+  usePageContext,
+  usePageProps,
+  usePageRoute,
+  usePageSdk
+};
+//# sourceMappingURL=index.mjs.map