contentoh-components-library 21.6.55 → 21.6.56

package/dist/global-files/digital-assets/assets.adapter.js

@@ -0,0 +1,304 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toPayload = exports.revokeAssetUrl = exports.isPersisted = exports.fromFile = exports.fromBackendList = exports.fromBackend = exports.filterByRetailer = exports.buildSavePayload = exports.buildAssetUrl = exports.assetTypeLabel = exports.assetKey = exports.ASSET_STATUS = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/typeof"));
+
+var _assetTypes = require("./assetTypes");
+
+/**
+ * Traducción entre el activo digital como lo guarda el backend y como lo usa la
+ * interfaz.
+ *
+ * DOS DECISIONES DEL NEGOCIO QUE SE NOTAN EN ESTE MODELO:
+ *
+ * - **Los activos no tienen versión.** Un activo general es el mismo sin
+ *   importar la versión del producto, así que no lleva `id_version` ni en el
+ *   modelo ni en la clave de S3. Eso evita el problema que sí tienen las
+ *   imágenes —copiar archivos al crear una versión— y hace que un video subido
+ *   en la v2 se vea también al mirar la v1.
+ * - **Por ahora todos son generales**, o sea `id_retailer = null`. La columna
+ *   existe y este adaptador ya la respeta para cuando se pida acotar un activo
+ *   a una cadena; hasta entonces nada la escribe.
+ *
+ * Es el único archivo que conoce los nombres de campo del backend. Mientras el
+ * contrato siga sin cerrarse, todo lo demás —tarjetas, bandeja, validaciones—
+ * se construye contra el modelo de esta capa; cuando el contrato quede fijo se
+ * ajustan estas funciones y nada más.
+ *
+ * El contrato propuesto está en `rel_article_asset`: una tabla aparte de
+ * `rel_article_image`, porque esa última guarda una sola fila por
+ * (artículo, versión, tipo de toma) y pisaría un activo con el siguiente.
+ */
+
+/**
+ * Estado de un activo en pantalla. `pending`/`uploading`/`error` solo existen
+ * en el navegador: un activo con id del backend siempre está `saved`.
+ */
+var ASSET_STATUS = {
+  PENDING: "pending",
+  UPLOADING: "uploading",
+  SAVED: "saved",
+  ERROR: "error"
+};
+exports.ASSET_STATUS = ASSET_STATUS;
+
+var IMAGES_BUCKET = function IMAGES_BUCKET() {
+  return process.env.REACT_APP_IMAGES_BUCKET;
+};
+/**
+ * URL directa al objeto en S3.
+ *
+ * A propósito NO pasa por el redimensionador de CloudFront: ese servicio
+ * reescribe la imagen con sharp y para un mp4, un gif animado o un pdf
+ * devuelve basura. Es la misma URL que ya usa la descarga de imágenes.
+ */
+
+
+var buildAssetUrl = function buildAssetUrl(key) {
+  if (!key) return "";
+  if (/^https?:\/\//i.test(key)) return key;
+  return "https://".concat(IMAGES_BUCKET(), ".s3.amazonaws.com/").concat(key);
+};
+/**
+ * `Number(null)` y `Number("")` son 0, no NaN. Sin descartarlos antes, un
+ * `id_retailer: null` —que significa "de todas las cadenas"— se convierte en el
+ * retailer 0 y el activo deja de verse en ninguna; una duración nula se vuelve
+ * un video de cero segundos.
+ */
+
+
+exports.buildAssetUrl = buildAssetUrl;
+
+var toNumberOrNull = function toNumberOrNull(value) {
+  if (value === null || value === undefined || value === "") return null;
+  var parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+/**
+ * Fila del backend -> modelo de interfaz.
+ *
+ * Acepta `url` ya resuelta si el backend la manda; si no, la arma desde la
+ * clave de S3. Así el front funciona igual con cualquiera de las dos formas del
+ * contrato y no hay que esperar a que se decida para seguir construyendo.
+ */
+
+
+var fromBackend = function fromBackend() {
+  var _row$id;
+
+  var row = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var ext = row.ext || (0, _assetTypes.getExtension)(row.name || row.src);
+  var assetType = row.asset_type || (0, _assetTypes.suggestAssetType)({
+    mime: row.mime,
+    name: row.name
+  });
+  return {
+    id: (_row$id = row.id) !== null && _row$id !== void 0 ? _row$id : null,
+    tempId: null,
+    assetType: assetType,
+    name: row.name || "",
+    ext: ext,
+    mime: row.mime || "",
+    sizeBytes: toNumberOrNull(row.size_bytes),
+    duration: toNumberOrNull(row.duration),
+    width: toNumberOrNull(row.width),
+    height: toNumberOrNull(row.height),
+    // Clave en S3. Se conserva porque es lo que el backend necesita de vuelta;
+    // la URL es derivada y no debe viajar en el payload.
+    src: row.src || "",
+    url: row.url || buildAssetUrl(row.src),
+    poster: row.poster ? buildAssetUrl(row.poster) : "",
+    // `id_retailer` nulo = activo general, que es lo único que se escribe hoy.
+    retailerId: toNumberOrNull(row.id_retailer),
+    createdAt: row.created_at || null,
+    file: null,
+    status: ASSET_STATUS.SAVED,
+    progress: 100,
+    error: null
+  };
+};
+
+exports.fromBackend = fromBackend;
+
+var fromBackendList = function fromBackendList() {
+  var rows = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return Array.isArray(rows) ? rows.map(fromBackend) : [];
+};
+
+exports.fromBackendList = fromBackendList;
+var tempCounter = 0;
+/**
+ * Archivo recién elegido -> modelo de interfaz.
+ *
+ * El `File` nativo se guarda tal cual, sin leerlo a base64. Convertirlo cuesta
+ * un tercio más de memoria y es lo que hoy vuelve imposible subir un video
+ * largo o un manual grande; con el `File` intacto da igual si termina subiendo
+ * por URL prefirmada o por el cliente de S3.
+ *
+ * El `tempId` permite seguirle la pista a un activo que todavía no tiene id del
+ * backend: sin él no hay forma de actualizar su progreso ni de quitarlo de la
+ * lista si falla.
+ */
+
+var fromFile = function fromFile(file) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      assetType = _ref.assetType,
+      objectUrl = _ref.objectUrl;
+
+  tempCounter += 1;
+  var ext = (0, _assetTypes.getExtension)(file === null || file === void 0 ? void 0 : file.name);
+  return {
+    id: null,
+    tempId: "tmp-".concat(Date.now(), "-").concat(tempCounter),
+    assetType: assetType || (0, _assetTypes.suggestAssetType)({
+      mime: file === null || file === void 0 ? void 0 : file.type,
+      name: file === null || file === void 0 ? void 0 : file.name
+    }),
+    name: (file === null || file === void 0 ? void 0 : file.name) || "",
+    ext: ext,
+    mime: (file === null || file === void 0 ? void 0 : file.type) || "",
+    sizeBytes: toNumberOrNull(file === null || file === void 0 ? void 0 : file.size),
+    duration: null,
+    width: null,
+    height: null,
+    src: "",
+    // `URL.createObjectURL` deja ver el archivo sin subirlo ni codificarlo.
+    // Quien lo crea es responsable de liberarlo con `revokeAssetUrl`.
+    url: objectUrl || "",
+    poster: "",
+    retailerId: null,
+    createdAt: null,
+    file: file,
+    status: ASSET_STATUS.PENDING,
+    progress: 0,
+    error: null
+  };
+};
+/** Identificador estable de un activo, tenga o no id del backend. */
+
+
+exports.fromFile = fromFile;
+
+var assetKey = function assetKey() {
+  var _ref2, _ref3, _asset$id;
+
+  var asset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (_ref2 = (_ref3 = (_asset$id = asset.id) !== null && _asset$id !== void 0 ? _asset$id : asset.tempId) !== null && _ref3 !== void 0 ? _ref3 : asset.src) !== null && _ref2 !== void 0 ? _ref2 : asset.name;
+};
+
+exports.assetKey = assetKey;
+
+var isPersisted = function isPersisted() {
+  var asset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return asset.id !== null && asset.id !== undefined;
+};
+/**
+ * Modelo de interfaz -> payload del backend.
+ *
+ * Nunca incluye `file` ni `url`: el archivo ya está en S3 cuando esto se envía
+ * y la URL es derivada. Es la misma razón por la que el guardado de imágenes
+ * borra `src`/`video_src` antes del PUT — el binario en el cuerpo devuelve 413.
+ */
+
+
+exports.isPersisted = isPersisted;
+
+var toPayload = function toPayload() {
+  var _asset$sizeBytes, _asset$duration, _asset$width, _asset$height;
+
+  var asset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var payload = {
+    asset_type: asset.assetType,
+    name: asset.name,
+    ext: asset.ext,
+    mime: asset.mime,
+    size_bytes: (_asset$sizeBytes = asset.sizeBytes) !== null && _asset$sizeBytes !== void 0 ? _asset$sizeBytes : null,
+    duration: (_asset$duration = asset.duration) !== null && _asset$duration !== void 0 ? _asset$duration : null,
+    width: (_asset$width = asset.width) !== null && _asset$width !== void 0 ? _asset$width : null,
+    height: (_asset$height = asset.height) !== null && _asset$height !== void 0 ? _asset$height : null,
+    key: asset.src || null
+  };
+  if (isPersisted(asset)) payload.id = asset.id;
+
+  if (asset.retailerId !== null && asset.retailerId !== undefined) {
+    payload.id_retailer = asset.retailerId;
+  }
+
+  return payload;
+};
+/**
+ * Separa la lista en lo que el backend espera recibir: altas, cambios y bajas.
+ * `deleted` son ids, no objetos, porque para borrar no hace falta nada más.
+ */
+
+
+exports.toPayload = toPayload;
+
+var buildSavePayload = function buildSavePayload() {
+  var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref4$assets = _ref4.assets,
+      assets = _ref4$assets === void 0 ? [] : _ref4$assets,
+      _ref4$updated = _ref4.updated,
+      updated = _ref4$updated === void 0 ? [] : _ref4$updated,
+      _ref4$deleted = _ref4.deleted,
+      deleted = _ref4$deleted === void 0 ? [] : _ref4$deleted;
+
+  return {
+    newAssets: assets.filter(function (asset) {
+      return !isPersisted(asset);
+    }).map(toPayload),
+    updateAssets: updated.filter(isPersisted).map(toPayload),
+    deleteAssets: deleted.map(function (asset) {
+      return (0, _typeof2.default)(asset) === "object" ? asset.id : asset;
+    }).filter(Boolean)
+  };
+};
+/**
+ * Qué activos ve la cadena activa: los generales (`retailerId` nulo) más los
+ * suyos.
+ *
+ * Hoy todos son generales, así que en la práctica no filtra nada. Se deja
+ * escrito y probado para el día que se pida acotar un activo a una cadena: ese
+ * día basta con que el backend mande el `id_retailer`, sin tocar la pantalla.
+ */
+
+
+exports.buildSavePayload = buildSavePayload;
+
+var filterByRetailer = function filterByRetailer() {
+  var assets = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var retailerId = arguments.length > 1 ? arguments[1] : undefined;
+  if (!retailerId) return assets;
+  return assets.filter(function (asset) {
+    return asset.retailerId === null || asset.retailerId === undefined || Number(asset.retailerId) === Number(retailerId);
+  });
+};
+/** Libera el object URL de un activo local. Sin esto el archivo se queda en memoria. */
+
+
+exports.filterByRetailer = filterByRetailer;
+
+var revokeAssetUrl = function revokeAssetUrl() {
+  var asset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  if (asset.file && asset.url && asset.url.startsWith("blob:")) {
+    URL.revokeObjectURL(asset.url);
+  }
+};
+/** Etiqueta legible del tipo, para badges y tablas. */
+
+
+exports.revokeAssetUrl = revokeAssetUrl;
+
+var assetTypeLabel = function assetTypeLabel() {
+  var asset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (0, _assetTypes.getAssetType)(asset.assetType).label;
+};
+
+exports.assetTypeLabel = assetTypeLabel;

package/dist/global-files/digital-assets/assets.mock.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.partialBackendAssetMock = exports.makeFileMock = exports.backendAssetsMock = void 0;
+
+/**
+ * Activos de ejemplo con la forma EXACTA que devolvería el backend, para
+ * Storybook y pruebas.
+ *
+ * Están crudos a propósito, sin pasar por `fromBackend`: así, si el contrato
+ * cambia, estos objetos se editan y el adaptador se prueba de verdad en vez de
+ * comparar el modelo de interfaz contra sí mismo.
+ */
+var backendAssetsMock = [{
+  id: 91,
+  asset_type: "360",
+  name: "giro_producto.mp4",
+  ext: "mp4",
+  mime: "video/mp4",
+  size_bytes: 8412160,
+  duration: 12,
+  width: 1080,
+  height: 1080,
+  src: "id-136038/assets/91-6d0f9a1e-0f0c-4a2b-9f1d-2a7c1b3e5d90.mp4",
+  poster: "id-136038/assets/91-6d0f9a1e-0f0c-4a2b-9f1d-2a7c1b3e5d90.jpg",
+  id_retailer: null,
+  created_at: "2026-09-10T16:22:04.000Z"
+}, {
+  id: 92,
+  asset_type: "360",
+  name: "giro_empaque.gif",
+  ext: "gif",
+  mime: "image/gif",
+  size_bytes: 3145728,
+  duration: null,
+  width: 800,
+  height: 800,
+  src: "id-136038/assets/92-b1c2d3e4-1111-2222-3333-444455556666.gif",
+  poster: null,
+  id_retailer: null,
+  created_at: "2026-09-10T16:24:41.000Z"
+}, {
+  id: 93,
+  asset_type: "video",
+  name: "demostracion_uso.mp4",
+  ext: "mp4",
+  mime: "video/mp4",
+  size_bytes: 54525952,
+  duration: 96,
+  width: 1920,
+  height: 1080,
+  src: "id-136038/assets/93-77aa88bb-99cc-4dd0-8ee1-ff0011223344.mp4",
+  poster: "id-136038/assets/93-77aa88bb-99cc-4dd0-8ee1-ff0011223344.jpg",
+  // Activo de una sola cadena: sirve para probar `filterByRetailer`.
+  id_retailer: 1017,
+  created_at: "2026-09-11T09:02:17.000Z"
+}, {
+  id: 94,
+  asset_type: "documento",
+  name: "manual_de_usuario.pdf",
+  ext: "pdf",
+  mime: "application/pdf",
+  size_bytes: 2418192,
+  duration: null,
+  width: null,
+  height: null,
+  src: "id-136038/assets/94-cc55dd66-7788-99aa-bbcc-ddeeff001122.pdf",
+  poster: null,
+  id_retailer: null,
+  created_at: "2026-09-12T11:48:00.000Z"
+}, {
+  id: 96,
+  asset_type: "editable",
+  name: "arte_empaque.psd",
+  ext: "psd",
+  // El navegador no le asigna mime a un .psd: llega vacío. Es el caso que
+  // obliga a resolver el tipo por extensión.
+  mime: "",
+  size_bytes: 268435456,
+  duration: null,
+  width: null,
+  height: null,
+  src: "id-136038/assets/96-11223344-5566-7788-99aa-bbccddeeff00.psd",
+  poster: null,
+  id_retailer: null,
+  created_at: "2026-09-15T10:12:33.000Z"
+}, {
+  id: 97,
+  asset_type: "hoja_calculo",
+  name: "tabla_de_medidas.xlsx",
+  ext: "xlsx",
+  mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  size_bytes: 48128,
+  duration: null,
+  width: null,
+  height: null,
+  src: "id-136038/assets/97-99887766-5544-3322-1100-ffeeddccbbaa.xlsx",
+  poster: null,
+  id_retailer: null,
+  created_at: "2026-09-15T10:14:02.000Z"
+}];
+/**
+ * Caso incompleto a propósito: sin `mime`, sin `ext` y sin `url`. El backend
+ * todavía no existe y es muy probable que las primeras respuestas lleguen así;
+ * el adaptador tiene que poder deducirlos del nombre y de la clave de S3.
+ */
+
+exports.backendAssetsMock = backendAssetsMock;
+var partialBackendAssetMock = {
+  id: 95,
+  name: "ficha_tecnica.pdf",
+  src: "id-136038/assets/95-aa11bb22-cc33-dd44-ee55-ff6677889900.pdf"
+};
+/** `File` falso para probar validaciones sin tocar disco ni red. */
+
+exports.partialBackendAssetMock = partialBackendAssetMock;
+
+var makeFileMock = function makeFileMock() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$name = _ref.name,
+      name = _ref$name === void 0 ? "giro_producto.mp4" : _ref$name,
+      _ref$type = _ref.type,
+      type = _ref$type === void 0 ? "video/mp4" : _ref$type,
+      _ref$size = _ref.size,
+      size = _ref$size === void 0 ? 8412160 : _ref$size;
+
+  return {
+    name: name,
+    type: type,
+    size: size
+  };
+};
+
+exports.makeFileMock = makeFileMock;

package/dist/global-files/digital-assets/assets.reducer.js

@@ -0,0 +1,220 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "assetsInitialState", {
+  enumerable: true,
+  get: function get() {
+    return _assets.assetsInitialState;
+  }
+});
+exports.selectAssetsToSave = exports.hasUnsavedAssets = exports.countUnsavedAssets = exports.assetsReducer = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+
+var _assets = require("./assets.actions");
+
+var _assets2 = require("./assets.adapter");
+
+/*
+  Estado de los activos digitales de la ficha.
+
+  Separado de `active-state` a propósito: ese reducer ya lleva 344 líneas y toda
+  la lógica de imágenes, que no comparte nada con esto —los activos no tienen
+  tipo de toma, ni obligatoriedad, ni cupo por cadena—.
+
+  Vive aquí y no en `context/reducers/` —donde están los otros cuatro— porque no
+  depende de la pantalla: es una función pura sobre activos, igual que el
+  adaptador y el catálogo. Así el hook y las historias de Storybook lo usan sin
+  arrastrar la ficha completa, y `provider-product-edition.reducer.js` solo lo
+  enchufa con una línea, igual que a los demás.
+
+  El reducer es puro. Liberar los object URL de los archivos locales es un efecto
+  y se hace en el hook antes de despachar; meterlo aquí rompería poder probar
+  este archivo sin navegador.
+*/
+var assetsReducer = function assetsReducer(state, action) {
+  switch (action.type) {
+    case _assets.ASSET_ACTIONS.SET_ASSETS_VALUES:
+      {
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          assets_values: Array.isArray(action.payload) ? action.payload : [],
+          // Lo que venga del backend es, por definición, lo ya guardado: no hay
+          // nada pendiente de enviar.
+          updated_assets: [],
+          deleted_assets: [],
+          selected_assets: [],
+          all_assets_checked: false
+        });
+      }
+
+    case _assets.ASSET_ACTIONS.ADD_ASSETS:
+      {
+        var incoming = Array.isArray(action.payload) ? action.payload : [action.payload];
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          assets_values: [].concat((0, _toConsumableArray2.default)(state.assets_values), (0, _toConsumableArray2.default)(incoming))
+        });
+      }
+
+    case _assets.ASSET_ACTIONS.UPDATE_ASSET:
+      {
+        var _action$payload = action.payload,
+            key = _action$payload.key,
+            changes = _action$payload.changes;
+        var touched = null;
+        var assets_values = state.assets_values.map(function (asset) {
+          if ((0, _assets2.assetKey)(asset) !== key) return asset;
+          touched = asset;
+          return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, asset), changes);
+        }); // Un activo que todavía no existe en el backend no se "actualiza": se
+        // creará con los valores finales, así que no hay nada que rastrear.
+
+        var shouldTrack = touched && (0, _assets2.isPersisted)(touched) && !state.updated_assets.includes(key);
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          assets_values: assets_values,
+          updated_assets: shouldTrack ? [].concat((0, _toConsumableArray2.default)(state.updated_assets), [key]) : state.updated_assets
+        });
+      }
+
+    case _assets.ASSET_ACTIONS.PATCH_ASSET:
+      {
+        var _action$payload2 = action.payload,
+            _key = _action$payload2.key,
+            _changes = _action$payload2.changes;
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          assets_values: state.assets_values.map(function (asset) {
+            return (0, _assets2.assetKey)(asset) === _key ? (0, _objectSpread2.default)((0, _objectSpread2.default)({}, asset), _changes) : asset;
+          })
+        });
+      }
+
+    case _assets.ASSET_ACTIONS.REMOVE_ASSET:
+      {
+        var _key2 = action.payload.key;
+        var target = state.assets_values.find(function (asset) {
+          return (0, _assets2.assetKey)(asset) === _key2;
+        });
+        if (!target) return state;
+
+        var _assets_values = state.assets_values.filter(function (asset) {
+          return (0, _assets2.assetKey)(asset) !== _key2;
+        });
+
+        var selected_assets = state.selected_assets.filter(function (asset) {
+          return (0, _assets2.assetKey)(asset) !== _key2;
+        });
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          assets_values: _assets_values,
+          // Solo se le pide al backend que borre lo que el backend tiene. Un
+          // activo local que nunca se subió simplemente desaparece.
+          deleted_assets: (0, _assets2.isPersisted)(target) ? [].concat((0, _toConsumableArray2.default)(state.deleted_assets), [target.id]) : state.deleted_assets,
+          // Sin esto, un activo borrado seguiría contando como seleccionado y como
+          // modificado: el guardado intentaría enviar un activo que ya no existe.
+          updated_assets: state.updated_assets.filter(function (item) {
+            return item !== _key2;
+          }),
+          selected_assets: selected_assets,
+          // Se recalcula en vez de apagarse: si estaban todos marcados y se borra
+          // uno, los que quedan siguen marcados y la casilla de "seleccionar todo"
+          // debe seguir reflejándolo.
+          all_assets_checked: _assets_values.length > 0 && selected_assets.length === _assets_values.length
+        });
+      }
+
+    case _assets.ASSET_ACTIONS.SET_SELECTED_ASSETS:
+      {
+        var selected = Array.isArray(action.payload) ? action.payload : [];
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          selected_assets: selected,
+          all_assets_checked: state.assets_values.length > 0 && selected.length === state.assets_values.length
+        });
+      }
+
+    case _assets.ASSET_ACTIONS.TOGGLE_CHECK_ALL_ASSETS:
+      {
+        // Con la lista vacía no hay nada que marcar: dejarlo en `true` pintaría la
+        // casilla de "seleccionar todo" activa sobre una bandeja sin activos.
+        var isChecked = Boolean(action.payload) && state.assets_values.length > 0;
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          all_assets_checked: isChecked,
+          selected_assets: isChecked ? (0, _toConsumableArray2.default)(state.assets_values) : []
+        });
+      }
+
+    case _assets.ASSET_ACTIONS.CLEAR_ASSETS_TRACKING:
+      {
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, state), {}, {
+          updated_assets: [],
+          deleted_assets: []
+        });
+      }
+
+    default:
+      {
+        return null;
+      }
+  }
+};
+/**
+ * Los tres grupos que espera el backend, listos para `buildSavePayload`.
+ *
+ * Se deriva de `assets_values` en el momento de guardar, no se acumula: las
+ * claves rastreadas dicen QUÉ cambió y el objeto vigente dice CÓMO quedó. Es lo
+ * que evita enviar el valor anterior cuando el usuario edita dos veces el mismo
+ * activo antes de guardar.
+ */
+
+
+exports.assetsReducer = assetsReducer;
+
+var selectAssetsToSave = function selectAssetsToSave(state) {
+  return {
+    assets: state.assets_values,
+    updated: state.assets_values.filter(function (asset) {
+      return state.updated_assets.includes((0, _assets2.assetKey)(asset));
+    }),
+    deleted: state.deleted_assets
+  };
+};
+/** ¿Hay algo sin guardar? Sirve para avisar antes de salir y para habilitar el botón. */
+
+/**
+ * Desglose de lo que falta por guardar.
+ *
+ * Se cuenta por separado —altas, cambios, bajas— y no como un número suelto
+ * porque "3 cambios sin guardar" no le dice al usuario qué perdería si se va:
+ * no es lo mismo dejar sin guardar un borrado que un archivo recién subido.
+ *
+ * Un activo nuevo solo cuenta si ya está en S3. Uno que todavía se está
+ * subiendo, o que falló, no es un cambio pendiente de guardar: es un archivo que
+ * aún no existe, y anunciarlo como tal haría que el contador subiera y bajara
+ * solo mientras la barra de progreso avanza.
+ */
+
+
+exports.selectAssetsToSave = selectAssetsToSave;
+
+var countUnsavedAssets = function countUnsavedAssets(state) {
+  var nuevos = state.assets_values.filter(function (asset) {
+    return !(0, _assets2.isPersisted)(asset) && Boolean(asset.src);
+  }).length;
+  return {
+    nuevos: nuevos,
+    modificados: state.updated_assets.length,
+    borrados: state.deleted_assets.length,
+    total: nuevos + state.updated_assets.length + state.deleted_assets.length
+  };
+};
+
+exports.countUnsavedAssets = countUnsavedAssets;
+
+var hasUnsavedAssets = function hasUnsavedAssets(state) {
+  return countUnsavedAssets(state).total > 0;
+};
+
+exports.hasUnsavedAssets = hasUnsavedAssets;