@strapi/admin 4.26.1 → 4.26.2

package/dist/_chunks/zh-twdFdR1U.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zh-twdFdR1U.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/index.js

@@ -1,76 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("../_chunks/index-B2pQGVY3.js");
-require("react/jsx-runtime");
-require("@strapi/helper-plugin");
-require("react-dom/client");
-require("@strapi/design-system");
-require("invariant");
-require("lodash/isFunction");
-require("lodash/merge");
-require("lodash/pick");
-require("react-helmet");
-require("react-router-dom");
-require("react");
-require("react-intl");
-require("react-redux");
-require("@reduxjs/toolkit");
-require("@reduxjs/toolkit/query/react");
-require("axios");
-require("@radix-ui/react-context");
-require("@strapi/design-system/v2");
-require("@strapi/icons");
-require("formik");
-require("lodash/camelCase");
-require("styled-components");
-require("yup");
-require("lodash/omit");
-require("qs");
-require("react-query");
-require("immer");
-require("lodash/get");
-require("lodash/set");
-require("lodash/defaultsDeep");
-require("lodash/isEqual");
-require("lodash/throttle");
-require("lodash/isBoolean");
-require("lodash/isEmpty");
-require("lodash/isNaN");
-require("lodash/toNumber");
-require("react-dnd");
-require("react-dnd-html5-backend");
-require("react-window");
-require("lodash/cloneDeep");
-require("lodash/upperFirst");
-require("prop-types");
-require("lodash/fp");
-require("lodash/take");
-require("slate");
-require("slate-history");
-require("slate-react");
-require("@radix-ui/react-toolbar");
-require("codemirror5");
-require("sanitize-html");
-require("highlight.js");
-require("markdown-it");
-require("markdown-it-abbr");
-require("markdown-it-container");
-require("markdown-it-deflist");
-require("markdown-it-emoji");
-require("markdown-it-footnote");
-require("markdown-it-ins");
-require("markdown-it-mark");
-require("markdown-it-sub");
-require("markdown-it-sup");
-require("highlight.js/styles/solarized-dark.css");
-require("codemirror5/addon/display/placeholder");
-require("lodash/toString");
-require("react-dom");
-require("fractional-indexing");
-require("lodash/uniqBy");
-require("lodash/unset");
-require("lodash/isArray");
-require("date-fns/parseISO");
+const index = require("../_chunks/index-BiELGgSr.js");
 exports.DefaultDocument = index.DefaultDocument;
 exports.renderAdmin = index.renderAdmin;
 exports.unstable_useDocument = index.useDocument;

package/dist/admin/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/admin/index.mjs

@@ -1,78 +1,8 @@
-import { Z, _, Y, m } from "../_chunks/index-QXnY1tED.mjs";
-import "react/jsx-runtime";
-import "@strapi/helper-plugin";
-import "react-dom/client";
-import "@strapi/design-system";
-import "invariant";
-import "lodash/isFunction";
-import "lodash/merge";
-import "lodash/pick";
-import "react-helmet";
-import "react-router-dom";
-import "react";
-import "react-intl";
-import "react-redux";
-import "@reduxjs/toolkit";
-import "@reduxjs/toolkit/query/react";
-import "axios";
-import "@radix-ui/react-context";
-import "@strapi/design-system/v2";
-import "@strapi/icons";
-import "formik";
-import "lodash/camelCase";
-import "styled-components";
-import "yup";
-import "lodash/omit";
-import "qs";
-import "react-query";
-import "immer";
-import "lodash/get";
-import "lodash/set";
-import "lodash/defaultsDeep";
-import "lodash/isEqual";
-import "lodash/throttle";
-import "lodash/isBoolean";
-import "lodash/isEmpty";
-import "lodash/isNaN";
-import "lodash/toNumber";
-import "react-dnd";
-import "react-dnd-html5-backend";
-import "react-window";
-import "lodash/cloneDeep";
-import "lodash/upperFirst";
-import "prop-types";
-import "lodash/fp";
-import "lodash/take";
-import "slate";
-import "slate-history";
-import "slate-react";
-import "@radix-ui/react-toolbar";
-import "codemirror5";
-import "sanitize-html";
-import "highlight.js";
-import "markdown-it";
-import "markdown-it-abbr";
-import "markdown-it-container";
-import "markdown-it-deflist";
-import "markdown-it-emoji";
-import "markdown-it-footnote";
-import "markdown-it-ins";
-import "markdown-it-mark";
-import "markdown-it-sub";
-import "markdown-it-sup";
-import "highlight.js/styles/solarized-dark.css";
-import "codemirror5/addon/display/placeholder";
-import "lodash/toString";
-import "react-dom";
-import "fractional-indexing";
-import "lodash/uniqBy";
-import "lodash/unset";
-import "lodash/isArray";
-import "date-fns/parseISO";
+import { Y, Z, _, m } from "../_chunks/index-Cwr9u7_W.mjs";
 export {
-  Z as DefaultDocument,
-  _ as renderAdmin,
-  Y as unstable_useDocument,
+  Y as DefaultDocument,
+  Z as renderAdmin,
+  _ as unstable_useDocument,
   m as useLicenseLimits
 };
 //# sourceMappingURL=index.mjs.map

package/dist/admin/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/cli.js

@@ -1,33 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("./_chunks/index-jOX8WAPL.js");
-require("@strapi/strapi/dist/utils/ee");
-require("@strapi/typescript-utils");
-require("node:os");
-require("node:fs/promises");
-require("node:path");
-require("inquirer");
-require("semver");
-require("resolve-from");
-require("execa");
-require("read-pkg-up");
-require("perf_hooks");
-require("outdent");
-require("prettier");
-require("react");
-require("react-dom/server");
-require("react/jsx-runtime");
-require("browserslist");
-require("@strapi/strapi");
-require("@strapi/utils");
-require("dotenv");
-require("esbuild-register/dist/node");
-require("node:fs");
-require("lodash/camelCase");
-require("boxen");
-require("chalk");
-require("chokidar");
-require("node:cluster");
+const index = require("./_chunks/index-WMsbcPLX.js");
 exports.build = index.build;
 exports.commands = index.index;
 exports.develop = index.develop;

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"cli.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/cli.mjs

@@ -1,31 +1,4 @@
-import { b, a, d } from "./_chunks/index-uXEcUT9H.mjs";
-import "@strapi/strapi/dist/utils/ee";
-import "@strapi/typescript-utils";
-import "node:os";
-import "node:fs/promises";
-import "node:path";
-import "inquirer";
-import "semver";
-import "resolve-from";
-import "execa";
-import "read-pkg-up";
-import "perf_hooks";
-import "outdent";
-import "prettier";
-import "react";
-import "react-dom/server";
-import "react/jsx-runtime";
-import "browserslist";
-import "@strapi/strapi";
-import "@strapi/utils";
-import "dotenv";
-import "esbuild-register/dist/node";
-import "node:fs";
-import "lodash/camelCase";
-import "boxen";
-import "chalk";
-import "chokidar";
-import "node:cluster";
+import { b, a, d } from "./_chunks/index-24f-Noga.mjs";
 export {
   b as build,
   a as commands,

package/dist/cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/ee/server/index.js

@@ -112,38 +112,12 @@ const adminAuthStrategy = {
   name: name$1,
   authenticate: authenticate$2
 };
-const DAY_IN_MS = 24 * 60 * 60 * 1e3;
 const constants = {
-  CONTENT_TYPE_SECTION: "contentTypes",
   SUPER_ADMIN_CODE: "strapi-super-admin",
-  EDITOR_CODE: "strapi-editor",
-  AUTHOR_CODE: "strapi-author",
-  READ_ACTION: "plugin::content-manager.explorer.read",
-  CREATE_ACTION: "plugin::content-manager.explorer.create",
-  UPDATE_ACTION: "plugin::content-manager.explorer.update",
-  DELETE_ACTION: "plugin::content-manager.explorer.delete",
-  PUBLISH_ACTION: "plugin::content-manager.explorer.publish",
   API_TOKEN_TYPE: {
     READ_ONLY: "read-only",
     FULL_ACCESS: "full-access",
     CUSTOM: "custom"
-  },
-  // The front-end only displays these values
-  API_TOKEN_LIFESPANS: {
-    UNLIMITED: null,
-    DAYS_7: 7 * DAY_IN_MS,
-    DAYS_30: 30 * DAY_IN_MS,
-    DAYS_90: 90 * DAY_IN_MS
-  },
-  TRANSFER_TOKEN_TYPE: {
-    PUSH: "push",
-    PULL: "pull"
-  },
-  TRANSFER_TOKEN_LIFESPANS: {
-    UNLIMITED: null,
-    DAYS_7: 7 * DAY_IN_MS,
-    DAYS_30: 30 * DAY_IN_MS,
-    DAYS_90: 90 * DAY_IN_MS
   }
 };
 const { UnauthorizedError: UnauthorizedError$1, ForbiddenError: ForbiddenError$1 } = utils$1.errors;
@@ -1612,25 +1586,7 @@ const authEventsMapper = {
   onConnectionSuccess: "admin.auth.success",
   onConnectionError: "admin.auth.error"
 };
-const valueIsFunctionType = ([, value]) => fp.isFunction(value);
-const keyIsValidEventName = ([key]) => {
-  return Object.keys(strapi.admin.services.passport.authEventsMapper).includes(key);
-};
-const getPassportStrategies$1 = () => [createLocalStrategy(strapi)];
-const registerAuthEvents = () => {
-  const { events = {} } = strapi.config.get("admin.auth", {});
-  const { authEventsMapper: authEventsMapper2 } = strapi.admin.services.passport;
-  const eventList = Object.entries(events).filter(keyIsValidEventName).filter(valueIsFunctionType);
-  for (const [eventName, handler] of eventList) {
-    strapi.eventHub.on(authEventsMapper2[eventName], handler);
-  }
-};
-const init = () => {
-  strapi.admin.services.passport.getPassportStrategies().forEach((strategy) => passport__default.default.use(strategy));
-  registerAuthEvents();
-  return passport__default.default.initialize();
-};
-const passport$1 = { init, getPassportStrategies: getPassportStrategies$1, authEventsMapper };
+const passport$1 = { authEventsMapper };
 const createProviderRegistry = () => {
   const registry = /* @__PURE__ */ new Map();
   Object.assign(registry, {
@@ -2670,7 +2626,7 @@ const reviewWorkflows = ({ strapi: strapi2 }) => {
   return {
     async bootstrap() {
       await registerWebhookEvents({ strapi: strapi2 });
-      await initDefaultWorkflow({ workflowsService, stagesService, strapi: strapi2 });
+      await initDefaultWorkflow({ workflowsService, stagesService });
     },
     async register({ options } = { options: {} }) {
       extendReviewWorkflowContentTypes({ strapi: strapi2 });
@@ -3160,12 +3116,18 @@ const role = {
     });
   }
 };
+function mergeValidatedBody(input, validatedPayload) {
+  if (validatedPayload !== null && typeof validatedPayload === "object" && !Array.isArray(validatedPayload)) {
+    return { ...input, ...validatedPayload };
+  }
+  return { ...input };
+}
 const getDefaultActionAttributes = () => ({
   options: {
     applyToProperties: null
   }
 });
-const actionFields = [
+const actionFields$1 = [
   "section",
   "displayName",
   "category",
@@ -3176,7 +3138,7 @@ const actionFields = [
   "actionId",
   "aliases"
 ];
-const sanitizeActionAttributes = fp.pick(actionFields);
+const sanitizeActionAttributes = fp.pick(actionFields$1);
 const computeActionId = (attributes) => {
   const { pluginName, uid } = attributes;
   if (!pluginName) {
@@ -3210,7 +3172,7 @@ const create = fp.pipe(
   fp.merge(getDefaultActionAttributes())
 );
 const actionDomain = {
-  actionFields,
+  actionFields: actionFields$1,
   appliesToProperty,
   appliesToSubject,
   assignActionId,
@@ -3232,8 +3194,7 @@ const checkFieldsAreCorrectlyNested = (fields) => {
     failed = fields.slice(indexA + 1).some(
       (fieldB) => fieldB.startsWith(`${fields[indexA]}.`) || fields[indexA].startsWith(`${fieldB}.`)
     );
-    if (failed)
-      break;
+    if (failed) break;
   }
   return !failed;
 };
@@ -3246,6 +3207,7 @@ const checkFieldsDontHaveDuplicates = (fields) => {
   }
   return ___default.default.uniq(fields).length === fields.length;
 };
+const { actionFields } = actionDomain;
 const getActionFromProvider = (actionId) => {
   return getService$1("permission").actionProvider.get(actionId);
 };
@@ -3255,10 +3217,10 @@ const lastname = utils$1.yup.string();
 const username = utils$1.yup.string().min(1);
 const password = utils$1.yup.string().min(8).matches(/[a-z]/, "${path} must contain at least one lowercase character").matches(/[A-Z]/, "${path} must contain at least one uppercase character").matches(/\d/, "${path} must contain at least one number");
 const roles = utils$1.yup.array(utils$1.yup.strapiID()).min(1);
-const isAPluginName = utils$1.yup.string().test("is-a-plugin-name", "is not a plugin name", function(value) {
+utils$1.yup.string().test("is-a-plugin-name", "is not a plugin name", function(value) {
   return [void 0, "admin", ...Object.keys(strapi.plugins)].includes(value) ? true : this.createError({ path: this.path, message: `${this.path} is not an existing plugin` });
 });
-const arrayOfConditionNames = utils$1.yup.array().of(utils$1.yup.string()).test("is-an-array-of-conditions", "is not a plugin name", function(value) {
+utils$1.yup.array().of(utils$1.yup.string()).test("is-an-array-of-conditions", "is not a plugin name", function(value) {
   const ids = strapi.admin.services.permission.conditionProvider.keys();
   return ___default.default.isUndefined(value) || ___default.default.difference(value, ids).length === 0 ? true : this.createError({ path: this.path, message: `contains conditions that don't exist` });
 });
@@ -3348,7 +3310,7 @@ const permission = utils$1.yup.object().shape({
   ),
   conditions: utils$1.yup.array().of(utils$1.yup.string())
 }).noUnknown();
-const updatePermissions = utils$1.yup.object().shape({
+utils$1.yup.object().shape({
   permissions: utils$1.yup.array().required().of(permission).test(
     "duplicated-permissions",
     "Some permissions are duplicated (same action and subject)",
@@ -3361,11 +3323,7 @@ const validators = {
   lastname,
   username,
   password,
-  roles,
-  isAPluginName,
-  arrayOfConditionNames,
-  permission,
-  updatePermissions
+  roles
 };
 const userCreationSchema = utils$1.yup.object().shape({
   email: validators.email.required(),
@@ -3399,13 +3357,29 @@ const usersDeleteSchema = utils$1.yup.object().shape({
   ids: utils$1.yup.array().of(utils$1.yup.strapiID()).min(1).required()
 }).noUnknown();
 utils$1.validateYupSchema(userCreationSchema);
+const normalizeUpdateInput = (input) => {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    return input;
+  }
+  const data = { ...input };
+  if (typeof data.email === "string") {
+    data.email = data.email.toLowerCase();
+  }
+  if (typeof data.firstname === "string") {
+    data.firstname = data.firstname.trim();
+  }
+  return data;
+};
 utils$1.validateYupSchema(profileUpdateSchema);
-const validateUserUpdateInput = utils$1.validateYupSchema(userUpdateSchema);
+const runUserUpdateValidation = utils$1.validateYupSchema(userUpdateSchema);
+const validateUserUpdateInput = async (input) => {
+  const data = normalizeUpdateInput(input);
+  const validated = await runUserUpdateValidation(data);
+  return mergeValidatedBody(data, validated);
+};
 utils$1.validateYupSchema(usersDeleteSchema);
 const schemas = {
-  userCreationSchema,
-  usersDeleteSchema,
-  userUpdateSchema
+  userCreationSchema
 };
 const ssoUserCreationInputExtension = utils$1.yup.object().shape({
   useSSORegistration: utils$1.yup.boolean()
@@ -3457,21 +3431,21 @@ const user = {
   async update(ctx) {
     const { id } = ctx.params;
     const { body: input } = ctx.request;
-    await validateUserUpdateInput(input);
-    if (___default.default.has(input, "email")) {
+    const data = await validateUserUpdateInput(input);
+    if (___default.default.has(data, "email")) {
       const uniqueEmailCheck = await getService("user").exists({
         id: { $ne: id },
-        email: input.email
+        email: data.email
       });
       if (uniqueEmailCheck) {
         throw new ApplicationError("A user with this email address already exists");
       }
     }
     const user2 = await getService("user").findOne(id, null);
-    if (!await hasAdminSeatsAvaialble() && !user2.isActive && input.isActive) {
+    if (!await hasAdminSeatsAvaialble() && !user2.isActive && data.isActive) {
       throw new ForbiddenError("License seat limit reached. You cannot active this user");
     }
-    const updatedUser = await getService("user").updateById(id, input);
+    const updatedUser = await getService("user").updateById(id, data);
     if (!updatedUser) {
       return ctx.notFound("User does not exist");
     }
@@ -3614,10 +3588,8 @@ function getWorkflowsPermissionChecker({ strapi: strapi2 }, userAbility) {
   return strapi2.plugin("content-manager").service("permission-checker").create({ userAbility, model: WORKFLOW_MODEL_UID });
 }
 function formatWorkflowToAdmin(workflow2) {
-  if (!workflow2)
-    return;
-  if (!workflow2.stages)
-    return workflow2;
+  if (!workflow2) return;
+  if (!workflow2.stages) return workflow2;
   const transformPermissions = fp.map(fp.update("role", fp.property("id")));
   const transformStages = fp.map(fp.update("permissions", transformPermissions));
   return fp.update("stages", transformStages, workflow2);