@nocobase/plugin-ui-layout 2.2.0-alpha.2

package/dist/server/plugin.js

@@ -0,0 +1,662 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  PluginUiLayoutServer: () => PluginUiLayoutServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@nocobase/server");
+var import_constants = require("../constants");
+var import_ensureDefaultUiLayout = require("./ensureDefaultUiLayout");
+const EMPTY_DESKTOP_ROUTE_FILTER = {
+  id: {
+    $eq: null
+  }
+};
+const UI_LAYOUT_RUNTIME_FIELDS = [
+  "uid",
+  "title",
+  "layoutType",
+  "routeName",
+  "routePath",
+  "authCheck",
+  "enabled"
+];
+const UI_LAYOUT_ROLE_PERMISSION_TARGET_FIELDS = ["uid", "title", "layoutType", "routeName", "enabled"];
+const DESKTOP_ROUTE_ROLE_PERMISSION_TARGET_FIELDS = ["id", "title", "hidden", "parentId", "options"];
+const ROUTES_MANAGEMENT_ACTIONS = ["desktopRoutes:list"];
+const ROLE_LAYOUT_PERMISSION_TARGET_ACTIONS = [
+  "uiLayouts:listRolePermissionTargets",
+  "desktopRoutes:listRolePermissionTargets"
+];
+const DESKTOP_ROUTE_WRITE_LAYOUT_HANDLER_TAG = "plugin-ui-layout:desktop-route-write-layout";
+const DEFAULT_ADMIN_UI_LAYOUT_PROTECTED_FIELDS = [
+  "uid",
+  "layoutType",
+  "routeName",
+  "routePath",
+  "authCheck",
+  "enabled"
+];
+function getRequestedLayoutUid(layout) {
+  return getExplicitRequestedLayoutUid(layout) ?? import_constants.DEFAULT_ADMIN_UI_LAYOUT.uid;
+}
+function getExplicitRequestedLayoutUid(layout) {
+  const uid = Array.isArray(layout) ? layout[0] : layout;
+  if (typeof uid === "string" && uid.trim()) {
+    return uid;
+  }
+}
+function hasActionParam(params, key) {
+  return !!params && typeof params === "object" && Object.prototype.hasOwnProperty.call(params, key);
+}
+function getDesktopRouteLayoutFilterByUid(layoutUid) {
+  return {
+    "uiLayouts.uid": layoutUid
+  };
+}
+function isDesktopRouteCreateValue(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isUiLayoutActionParams(value) {
+  return isDesktopRouteCreateValue(value);
+}
+function isDefaultAdminUiLayoutRecord(record) {
+  return record.get("uid") === import_constants.DEFAULT_ADMIN_UI_LAYOUT.uid;
+}
+function hasUnsafeDefaultAdminUiLayoutValues(values) {
+  if (!isDesktopRouteCreateValue(values)) {
+    return false;
+  }
+  return DEFAULT_ADMIN_UI_LAYOUT_PROTECTED_FIELDS.some(
+    (field) => Object.prototype.hasOwnProperty.call(values, field) && values[field] !== import_constants.DEFAULT_ADMIN_UI_LAYOUT[field]
+  );
+}
+async function findUiLayoutActionTargets(ctx) {
+  var _a;
+  const params = (_a = ctx.action) == null ? void 0 : _a.params;
+  if (!isUiLayoutActionParams(params)) {
+    return [];
+  }
+  const repository = ctx.db.getRepository("uiLayouts");
+  const filterByTk = params.filterByTk ?? params.filterByTks;
+  if (filterByTk !== void 0 && filterByTk !== null) {
+    return repository.find({
+      filterByTk
+    });
+  }
+  if (params.filter && Object.keys(params.filter).length) {
+    return repository.find({
+      filter: params.filter
+    });
+  }
+  return [];
+}
+function hasUiLayout(uiLayout, layoutUid) {
+  if (uiLayout === layoutUid) {
+    return true;
+  }
+  return isDesktopRouteCreateValue(uiLayout) && uiLayout.uid === layoutUid;
+}
+function mergeUiLayoutValue(uiLayouts, layoutUid) {
+  if (Array.isArray(uiLayouts)) {
+    if (uiLayouts.some((uiLayout) => hasUiLayout(uiLayout, layoutUid))) {
+      return uiLayouts;
+    }
+    return [...uiLayouts, layoutUid];
+  }
+  if (hasUiLayout(uiLayouts, layoutUid)) {
+    return uiLayouts;
+  }
+  return uiLayouts == null ? [layoutUid] : [uiLayouts, layoutUid];
+}
+function withDesktopRouteUiLayout(value, layoutUid) {
+  if (Array.isArray(value)) {
+    return value.map((item) => withDesktopRouteUiLayout(item, layoutUid));
+  }
+  if (!isDesktopRouteCreateValue(value)) {
+    return value;
+  }
+  return {
+    ...value,
+    uiLayouts: mergeUiLayoutValue(value.uiLayouts, layoutUid),
+    ...Array.isArray(value.children) ? { children: withDesktopRouteUiLayout(value.children, layoutUid) } : {}
+  };
+}
+async function getDesktopRouteLayoutContext(ctx) {
+  var _a;
+  const requestedLayout = (_a = ctx.action) == null ? void 0 : _a.params.layout;
+  const layoutUid = requestedLayout === void 0 ? import_constants.DEFAULT_ADMIN_UI_LAYOUT.uid : getExplicitRequestedLayoutUid(requestedLayout);
+  if (!layoutUid) {
+    return {
+      filter: EMPTY_DESKTOP_ROUTE_FILTER,
+      valid: false
+    };
+  }
+  const uiLayout = await ctx.db.getRepository("uiLayouts").findOne({
+    filter: {
+      uid: layoutUid,
+      enabled: true
+    }
+  });
+  if (!uiLayout) {
+    return {
+      filter: EMPTY_DESKTOP_ROUTE_FILTER,
+      layoutUid,
+      valid: false
+    };
+  }
+  return {
+    filter: getDesktopRouteLayoutFilterByUid(layoutUid),
+    layoutUid,
+    valid: true
+  };
+}
+function getRouteValue(route, key) {
+  if (!route || typeof route !== "object") {
+    return;
+  }
+  const maybeModel = route;
+  if (typeof maybeModel.get === "function") {
+    return maybeModel.get(key);
+  }
+  return route[key];
+}
+function getRouteId(route) {
+  const id = getRouteValue(route, "id");
+  return id === null || id === void 0 ? void 0 : String(id);
+}
+function getRouteParentId(route) {
+  const parentId = getRouteValue(route, "parentId");
+  return parentId === null || parentId === void 0 ? void 0 : String(parentId);
+}
+function setRouteChildren(route, children) {
+  if (!route || typeof route !== "object") {
+    return;
+  }
+  const maybeModel = route;
+  if (typeof maybeModel.setDataValue === "function") {
+    maybeModel.setDataValue("children", children);
+  } else {
+    maybeModel.children = children;
+  }
+  if (!maybeModel._options) {
+    return;
+  }
+  if (!maybeModel._options.includeNames) {
+    maybeModel._options.includeNames = ["children"];
+    return;
+  }
+  if (!maybeModel._options.includeNames.includes("children")) {
+    maybeModel._options.includeNames.push("children");
+  }
+}
+function collectRouteIds(routes, ids) {
+  for (const route of routes) {
+    const id = getRouteId(route);
+    if (id) {
+      ids.add(id);
+    }
+    const children = getRouteValue(route, "children");
+    if (Array.isArray(children)) {
+      collectRouteIds(children, ids);
+    }
+  }
+}
+function removeNestedRootRoutes(routes) {
+  if (!Array.isArray(routes)) {
+    return [];
+  }
+  const routeIds = /* @__PURE__ */ new Set();
+  collectRouteIds(routes, routeIds);
+  return routes.filter((route) => {
+    const parentId = getRouteParentId(route);
+    return !parentId || !routeIds.has(parentId);
+  });
+}
+async function removeRouteIdsWithUnauthorizedAncestors(ctx, routeIds) {
+  if (routeIds.size === 0) {
+    return;
+  }
+  const parentIdByRouteId = /* @__PURE__ */ new Map();
+  let pendingRouteIds = new Set(routeIds);
+  while (pendingRouteIds.size > 0) {
+    const routes = await ctx.db.getRepository("desktopRoutes").find({
+      fields: ["id", "parentId"],
+      filter: {
+        id: Array.from(pendingRouteIds)
+      }
+    });
+    pendingRouteIds = /* @__PURE__ */ new Set();
+    for (const route of routes) {
+      const routeId = route.get("id");
+      if (routeId === null || routeId === void 0) {
+        continue;
+      }
+      const normalizedRouteId = String(routeId);
+      const parentId = route.get("parentId");
+      const normalizedParentId = parentId === null || parentId === void 0 ? void 0 : String(parentId);
+      parentIdByRouteId.set(normalizedRouteId, normalizedParentId);
+      if (normalizedParentId && !parentIdByRouteId.has(normalizedParentId)) {
+        pendingRouteIds.add(normalizedParentId);
+      }
+    }
+  }
+  for (const routeId of Array.from(routeIds)) {
+    const visitedRouteIds = /* @__PURE__ */ new Set([routeId]);
+    let parentId = parentIdByRouteId.get(routeId);
+    while (parentId) {
+      if (!routeIds.has(parentId) || visitedRouteIds.has(parentId)) {
+        routeIds.delete(routeId);
+        break;
+      }
+      visitedRouteIds.add(parentId);
+      parentId = parentIdByRouteId.get(parentId);
+    }
+  }
+}
+async function addDesktopRouteWriteLayout(ctx, next) {
+  var _a, _b, _c;
+  const params = (_a = ctx.action) == null ? void 0 : _a.params;
+  const hasExplicitLayoutScope = hasActionParam(params, "layout");
+  const explicitLayoutUid = hasExplicitLayoutScope ? getExplicitRequestedLayoutUid(params.layout) : void 0;
+  if (hasExplicitLayoutScope && !explicitLayoutUid) {
+    ctx.throw(400, ctx.t("Invalid layout scope", { ns: import_constants.NAMESPACE }));
+    return;
+  }
+  const layoutUid = explicitLayoutUid ?? import_constants.DEFAULT_ADMIN_UI_LAYOUT.uid;
+  const uiLayout = await ctx.db.getRepository("uiLayouts").findOne({
+    filter: {
+      uid: layoutUid,
+      enabled: true
+    }
+  });
+  if (!uiLayout && hasExplicitLayoutScope) {
+    ctx.throw(400, ctx.t("Invalid layout scope", { ns: import_constants.NAMESPACE }));
+    return;
+  }
+  if (uiLayout) {
+    (_c = ctx.action) == null ? void 0 : _c.mergeParams({
+      values: withDesktopRouteUiLayout((_b = ctx.action) == null ? void 0 : _b.params.values, layoutUid)
+    });
+  }
+  await next();
+}
+async function preventUiLayoutUidChange(ctx, next) {
+  var _a, _b;
+  const values = (_a = ctx.action) == null ? void 0 : _a.params.values;
+  if (!isDesktopRouteCreateValue(values) || !Object.prototype.hasOwnProperty.call(values, "uid")) {
+    await next();
+    return;
+  }
+  const requestedUid = values.uid;
+  const filterByTk = (_b = ctx.action) == null ? void 0 : _b.params.filterByTk;
+  if (typeof requestedUid !== "string" || filterByTk === null || filterByTk === void 0 || Array.isArray(filterByTk)) {
+    ctx.throw(400, ctx.t("UID cannot be changed", { ns: import_constants.NAMESPACE }));
+    return;
+  }
+  const record = await ctx.db.getRepository("uiLayouts").findOne({
+    filterByTk
+  });
+  if (record && record.get("uid") !== requestedUid) {
+    ctx.throw(400, ctx.t("UID cannot be changed", { ns: import_constants.NAMESPACE }));
+    return;
+  }
+  await next();
+}
+async function preventDefaultAdminUiLayoutUpdate(ctx, next) {
+  var _a;
+  if (!hasUnsafeDefaultAdminUiLayoutValues((_a = ctx.action) == null ? void 0 : _a.params.values)) {
+    await next();
+    return;
+  }
+  const targets = await findUiLayoutActionTargets(ctx);
+  if (targets.some(isDefaultAdminUiLayoutRecord)) {
+    ctx.throw(400, ctx.t("Default AdminLayout cannot be changed", { ns: import_constants.NAMESPACE }));
+    return;
+  }
+  await next();
+}
+async function preventDefaultAdminUiLayoutDestroy(ctx, next) {
+  const targets = await findUiLayoutActionTargets(ctx);
+  if (targets.some(isDefaultAdminUiLayoutRecord)) {
+    ctx.throw(400, ctx.t("Default AdminLayout cannot be deleted", { ns: import_constants.NAMESPACE }));
+    return;
+  }
+  await next();
+}
+function getCurrentRoles(ctx) {
+  const currentRoles = ctx.state.currentRoles;
+  if (!Array.isArray(currentRoles)) {
+    return [];
+  }
+  return currentRoles.filter((role) => typeof role === "string");
+}
+async function getLayoutAccessibleRouteIds(ctx, layoutUid) {
+  const currentRoles = getCurrentRoles(ctx);
+  if (currentRoles.includes("root")) {
+    return;
+  }
+  const routePermissions = await ctx.db.getRepository("rolesDesktopRoutes").find({
+    fields: ["desktopRouteId"],
+    filter: {
+      roleName: currentRoles
+    }
+  });
+  const permittedRouteIds = /* @__PURE__ */ new Set();
+  for (const permission of routePermissions) {
+    const routeId = permission.get("desktopRouteId");
+    if (routeId !== null && routeId !== void 0) {
+      permittedRouteIds.add(String(routeId));
+    }
+  }
+  if (permittedRouteIds.size === 0) {
+    return permittedRouteIds;
+  }
+  const layoutRoutes = await ctx.db.getRepository("desktopRoutes").find({
+    fields: ["id"],
+    filter: {
+      ...getDesktopRouteLayoutFilterByUid(layoutUid),
+      id: Array.from(permittedRouteIds)
+    }
+  });
+  const routeIds = /* @__PURE__ */ new Set();
+  for (const route of layoutRoutes) {
+    const routeId = route.get("id");
+    if (routeId !== null && routeId !== void 0) {
+      routeIds.add(String(routeId));
+    }
+  }
+  await removeRouteIdsWithUnauthorizedAncestors(ctx, routeIds);
+  return routeIds;
+}
+function removeInaccessibleRoute(route, allowedRouteIds) {
+  if (!route || !allowedRouteIds) {
+    return route;
+  }
+  const id = getRouteId(route);
+  if (!id || !allowedRouteIds.has(id)) {
+    return null;
+  }
+  return route;
+}
+function buildAccessibleRouteTreeWithAncestors(routes, accessibleRouteIds) {
+  const routeById = /* @__PURE__ */ new Map();
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const route of routes) {
+    const id = getRouteId(route);
+    if (!id) {
+      continue;
+    }
+    setRouteChildren(route, void 0);
+    routeById.set(id, route);
+  }
+  for (const route of routes) {
+    const id = getRouteId(route);
+    if (!id || !routeById.has(id)) {
+      continue;
+    }
+    const parentId = getRouteParentId(route);
+    if (!parentId || !routeById.has(parentId)) {
+      roots.push(route);
+      continue;
+    }
+    const children = childrenByParentId.get(parentId) ?? [];
+    children.push(route);
+    childrenByParentId.set(parentId, children);
+  }
+  const visitRoute = (route, visitingRouteIds) => {
+    const id = getRouteId(route);
+    if (!id || visitingRouteIds.has(id)) {
+      return void 0;
+    }
+    visitingRouteIds.add(id);
+    const children = childrenByParentId.get(id) ?? [];
+    const visibleChildren = children.map((child) => visitRoute(child, visitingRouteIds)).filter((child) => child !== void 0);
+    visitingRouteIds.delete(id);
+    if (!accessibleRouteIds.has(id) && visibleChildren.length === 0) {
+      return void 0;
+    }
+    setRouteChildren(route, visibleChildren.length > 0 ? visibleChildren : void 0);
+    return route;
+  };
+  return roots.map((route) => visitRoute(route, /* @__PURE__ */ new Set())).filter((route) => route !== void 0);
+}
+async function includeRouteAncestorsForListAccessible(ctx, routes, layoutFilter) {
+  if (!Array.isArray(routes) || getCurrentRoles(ctx).includes("root")) {
+    return routes;
+  }
+  const accessibleRouteIds = /* @__PURE__ */ new Set();
+  collectRouteIds(routes, accessibleRouteIds);
+  if (accessibleRouteIds.size === 0) {
+    return routes;
+  }
+  const layoutRoutes = await ctx.db.getRepository("desktopRoutes").find({
+    sort: "sort",
+    filter: layoutFilter
+  });
+  return buildAccessibleRouteTreeWithAncestors(layoutRoutes, accessibleRouteIds);
+}
+async function addDesktopRouteLayoutFilter(ctx, next) {
+  var _a, _b;
+  const layoutContext = await getDesktopRouteLayoutContext(ctx);
+  (_a = ctx.action) == null ? void 0 : _a.mergeParams({
+    filter: layoutContext.filter
+  });
+  await next();
+  if (!layoutContext.valid || !layoutContext.layoutUid) {
+    ctx.body = [];
+    return;
+  }
+  if (getCurrentRoles(ctx).includes("root")) {
+    ctx.body = removeNestedRootRoutes(
+      await includeRouteAncestorsForListAccessible(ctx, ctx.body, layoutContext.filter)
+    );
+    return;
+  }
+  const routeIds = await getLayoutAccessibleRouteIds(ctx, layoutContext.layoutUid);
+  if (!routeIds || routeIds.size === 0) {
+    ctx.body = [];
+    return;
+  }
+  const routes = await ctx.db.getRepository("desktopRoutes").find({
+    tree: true,
+    sort: "sort",
+    filter: {
+      ...(_b = ctx.action) == null ? void 0 : _b.params.filter,
+      id: Array.from(routeIds)
+    }
+  });
+  ctx.body = removeNestedRootRoutes(await includeRouteAncestorsForListAccessible(ctx, routes, layoutContext.filter));
+}
+async function addDesktopRouteGetLayoutFilter(ctx, next) {
+  var _a, _b, _c;
+  const layoutContext = await getDesktopRouteLayoutContext(ctx);
+  (_a = ctx.action) == null ? void 0 : _a.mergeParams({
+    filter: layoutContext.filter
+  });
+  await next();
+  if (!layoutContext.valid || !layoutContext.layoutUid) {
+    ctx.status = 204;
+    ctx.body = void 0;
+    return;
+  }
+  if (getCurrentRoles(ctx).includes("root")) {
+    if (ctx.body) {
+      return;
+    }
+    ctx.status = 204;
+    ctx.body = void 0;
+    return;
+  }
+  const routeIds = await getLayoutAccessibleRouteIds(ctx, layoutContext.layoutUid);
+  let route = removeInaccessibleRoute(ctx.body, routeIds);
+  if (!route && routeIds && routeIds.size > 0) {
+    route = await ctx.db.getRepository("desktopRoutes").findOne({
+      sort: "sort",
+      ...(_b = ctx.action) == null ? void 0 : _b.params,
+      filter: {
+        ...(_c = ctx.action) == null ? void 0 : _c.params.filter,
+        id: Array.from(routeIds)
+      }
+    });
+  }
+  if (route == null) {
+    ctx.status = 204;
+    ctx.body = void 0;
+    return;
+  }
+  ctx.body = route;
+}
+function pickUiLayoutRuntimeFields(record) {
+  const result = {};
+  for (const field of UI_LAYOUT_RUNTIME_FIELDS) {
+    result[field] = record.get(field);
+  }
+  return result;
+}
+function pickUiLayoutRolePermissionTargetFields(record) {
+  const result = {};
+  for (const field of UI_LAYOUT_ROLE_PERMISSION_TARGET_FIELDS) {
+    result[field] = record.get(field);
+  }
+  return result;
+}
+function pickDesktopRouteRolePermissionTargetFields(route) {
+  const result = {};
+  for (const field of DESKTOP_ROUTE_ROLE_PERMISSION_TARGET_FIELDS) {
+    result[field] = getRouteValue(route, field) ?? null;
+  }
+  const children = getRouteValue(route, "children");
+  result.children = Array.isArray(children) ? children.map((child) => pickDesktopRouteRolePermissionTargetFields(child)) : [];
+  return result;
+}
+async function listAccessibleUiLayouts(ctx, next) {
+  const records = await ctx.db.getRepository("uiLayouts").find({
+    filter: {
+      enabled: true
+    },
+    fields: [...UI_LAYOUT_RUNTIME_FIELDS],
+    sort: ["uid"]
+  });
+  ctx.body = records.map((record) => pickUiLayoutRuntimeFields(record));
+  await next();
+}
+async function listEnabledUiLayouts(ctx, next) {
+  const records = await ctx.db.getRepository("uiLayouts").find({
+    filter: {
+      enabled: true
+    },
+    fields: [...UI_LAYOUT_RUNTIME_FIELDS],
+    sort: ["uid"]
+  });
+  ctx.body = records.map((record) => pickUiLayoutRuntimeFields(record));
+  await next();
+}
+async function listUiLayoutRolePermissionTargets(ctx, next) {
+  const records = await ctx.db.getRepository("uiLayouts").find({
+    filter: {
+      enabled: true
+    },
+    fields: [...UI_LAYOUT_ROLE_PERMISSION_TARGET_FIELDS],
+    sort: ["uid"]
+  });
+  ctx.body = records.map((record) => pickUiLayoutRolePermissionTargetFields(record));
+  await next();
+}
+async function listDesktopRouteRolePermissionTargets(ctx, next) {
+  const layoutContext = await getDesktopRouteLayoutContext(ctx);
+  if (!layoutContext.valid) {
+    ctx.body = [];
+    await next();
+    return;
+  }
+  const routes = await ctx.db.getRepository("desktopRoutes").find({
+    tree: true,
+    sort: "sort",
+    filter: layoutContext.filter,
+    fields: [...DESKTOP_ROUTE_ROLE_PERMISSION_TARGET_FIELDS]
+  });
+  ctx.body = removeNestedRootRoutes(routes).map((route) => pickDesktopRouteRolePermissionTargetFields(route));
+  await next();
+}
+class PluginUiLayoutServer extends import_server.Plugin {
+  async afterAdd() {
+  }
+  async beforeLoad() {
+  }
+  async load() {
+    this.app.acl.registerSnippet({
+      name: "pm.routes",
+      actions: ROUTES_MANAGEMENT_ACTIONS
+    });
+    this.app.acl.registerSnippet({
+      name: "pm.acl.roles",
+      actions: ROLE_LAYOUT_PERMISSION_TARGET_ACTIONS
+    });
+    this.app.acl.allow("uiLayouts", "listEnabled", "public");
+    this.app.acl.allow("uiLayouts", "listAccessible", "loggedIn");
+    this.app.resourceManager.registerActionHandler("uiLayouts:listEnabled", listEnabledUiLayouts);
+    this.app.resourceManager.registerActionHandler("uiLayouts:listAccessible", listAccessibleUiLayouts);
+    this.app.resourceManager.registerActionHandler(
+      "uiLayouts:listRolePermissionTargets",
+      listUiLayoutRolePermissionTargets
+    );
+    this.app.resourceManager.registerActionHandler(
+      "desktopRoutes:listRolePermissionTargets",
+      listDesktopRouteRolePermissionTargets
+    );
+    this.app.resourceManager.registerPreActionHandler("uiLayouts:update", preventUiLayoutUidChange);
+    this.app.resourceManager.registerPreActionHandler("uiLayouts:update", preventDefaultAdminUiLayoutUpdate);
+    this.app.resourceManager.registerPreActionHandler("uiLayouts:destroy", preventDefaultAdminUiLayoutDestroy);
+    this.app.resourceManager.registerPreActionHandler("desktopRoutes:create", addDesktopRouteWriteLayout, {
+      tag: DESKTOP_ROUTE_WRITE_LAYOUT_HANDLER_TAG
+    });
+    this.app.resourceManager.registerPreActionHandler("desktopRoutes:updateOrCreate", addDesktopRouteWriteLayout, {
+      tag: DESKTOP_ROUTE_WRITE_LAYOUT_HANDLER_TAG
+    });
+    this.app.resourceManager.registerPreActionHandler("desktopRoutes:listAccessible", addDesktopRouteLayoutFilter);
+    this.app.resourceManager.registerPreActionHandler("desktopRoutes:getAccessible", addDesktopRouteGetLayoutFilter);
+  }
+  async install() {
+    await (0, import_ensureDefaultUiLayout.ensureDefaultUiLayout)(this.db);
+  }
+  async afterEnable() {
+    await (0, import_ensureDefaultUiLayout.ensureDefaultUiLayout)(this.db);
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+}
+var plugin_default = PluginUiLayoutServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginUiLayoutServer
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@nocobase/plugin-ui-layout",
+  "version": "2.2.0-alpha.2",
+  "license": "Apache-2.0",
+  "main": "dist/server/index.js",
+  "displayName": "UI layout",
+  "displayName.zh-CN": "UI 布局",
+  "description": "Provides desktop layout, mobile layout, and route management pages.",
+  "description.zh-CN": "提供桌面端布局、移动端布局、路由管理页面。",
+  "devDependencies": {
+    "@ant-design/icons": "5.x",
+    "@dnd-kit/core": "^6.0.0",
+    "@emotion/css": "11.x",
+    "@formily/antd-v5": "1.x",
+    "@formily/json-schema": "2.x",
+    "@formily/react": "2.x",
+    "@formily/reactive": "2.x",
+    "@formily/shared": "2.x",
+    "ahooks": "3.x",
+    "antd": "5.x",
+    "lodash": "4.x",
+    "react": "^18.2.0",
+    "react-i18next": "11.x",
+    "react-router-dom": "6.x",
+    "sequelize": "^6.26.0"
+  },
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/client-v2": "2.x",
+    "@nocobase/database": "2.x",
+    "@nocobase/flow-engine": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/test": "2.x",
+    "@nocobase/utils": "2.x"
+  },
+  "gitHead": "9dd5224bb8f6c1ac12d766b9f175bdc29bddd845"
+}

package/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');