@plone/volto 18.32.1 → 18.32.3

package/src/helpers/Blocks/Blocks.test.js

@@ -7,6 +7,7 @@ import {
   getBlocks,
   getBlocksFieldname,
   getBlocksLayoutFieldname,
+  getInvalidBlockLayoutIds,
   hasBlocksData,
   insertBlock,
   moveBlock,
@@ -482,6 +483,105 @@ describe('Blocks', () => {
         ['a', { value: 1 }],
       ]);
     });
+
+    it('filters out invalid block IDs (null, undefined, string "undefined")', () => {
+      const validBlock = { '@type': 'search', value: 'test' };
+      const result = getBlocks({
+        blocks: {
+          'valid-id-123': validBlock,
+          // These shouldn't exist but test edge case
+          [null]: { '@type': 'invalid' },
+          [undefined]: { '@type': 'invalid' },
+          undefined: { '@type': 'invalid' },
+        },
+        blocks_layout: {
+          items: [
+            'valid-id-123',
+            null, // Invalid: null ID
+            undefined, // Invalid: undefined ID
+            'undefined', // Invalid: string "undefined"
+            'missing-block', // Valid ID but block doesn't exist (filtered by block !== undefined)
+          ],
+        },
+      });
+
+      // Should only return the valid block, filtering out:
+      // - null ID
+      // - undefined ID
+      // - string "undefined" ID
+      // - missing block (block is undefined)
+      expect(result).toStrictEqual([['valid-id-123', validBlock]]);
+      expect(result.length).toBe(1);
+
+      // Verify no invalid IDs in the result
+      const ids = result.map(([id]) => id);
+      expect(ids).not.toContain(null);
+      expect(ids).not.toContain(undefined);
+      expect(ids).not.toContain('undefined');
+    });
+
+    it('filters out invalid block IDs even when blocks object has invalid keys', () => {
+      // Simulate edge case where blocks object has invalid keys
+      const blocks = {
+        'valid-id': { '@type': 'search' },
+      };
+      // JavaScript allows this, creating string keys
+      blocks[null] = { '@type': 'invalid' };
+      blocks[undefined] = { '@type': 'invalid' };
+
+      const result = getBlocks({
+        blocks,
+        blocks_layout: {
+          items: ['valid-id', null, undefined, 'undefined'],
+        },
+      });
+
+      // Should only return valid block
+      expect(result).toStrictEqual([['valid-id', { '@type': 'search' }]]);
+      expect(result.length).toBe(1);
+    });
+  });
+
+  describe('getInvalidBlockLayoutIds', () => {
+    it('returns layout IDs that are valid but have no block data', () => {
+      const result = getInvalidBlockLayoutIds({
+        blocks: {
+          a: { '@type': 'custom', text: 'a' },
+          b: { '@type': 'custom', text: 'b' },
+        },
+        blocks_layout: {
+          items: ['a', 'b', 'MISSING-1', 'MISSING-2'],
+        },
+      });
+      expect(result).toStrictEqual(['MISSING-1', 'MISSING-2']);
+    });
+
+    it('returns empty when all layout items have block data', () => {
+      const result = getInvalidBlockLayoutIds({
+        blocks: { a: { '@type': 'custom' }, b: { '@type': 'custom' } },
+        blocks_layout: { items: ['a', 'b'] },
+      });
+      expect(result).toStrictEqual([]);
+    });
+
+    it('filters out invalid IDs (null, undefined, "undefined")', () => {
+      const result = getInvalidBlockLayoutIds({
+        blocks: {},
+        blocks_layout: {
+          items: [null, undefined, 'undefined', 'valid-missing'],
+        },
+      });
+      expect(result).toStrictEqual(['valid-missing']);
+    });
+
+    it('returns empty when items is missing or empty', () => {
+      expect(
+        getInvalidBlockLayoutIds({ blocks: {}, blocks_layout: {} }),
+      ).toStrictEqual([]);
+      expect(
+        getInvalidBlockLayoutIds({ blocks: {}, blocks_layout: { items: [] } }),
+      ).toStrictEqual([]);
+    });
   });
 
   describe('addBlock', () => {

package/src/helpers/FormValidation/FormValidation.test.js

@@ -8,6 +8,18 @@ const schema = {
     username: { title: 'Username', type: 'string', description: '' },
     email: { title: 'Email', type: 'string', widget: 'email', description: '' },
     url: { title: 'url', type: 'string', widget: 'url', description: '' },
+    file: {
+      title: 'file',
+      type: 'object',
+      description: '',
+      size: 5,
+    },
+    notafile: {
+      title: 'notafile',
+      type: 'object',
+      description: '',
+      whatever: 1,
+    },
   },
   fieldsets: [
     { id: 'default', title: 'FIXME: User Data', fields: ['username'] },
@@ -181,6 +193,41 @@ describe('FormValidation', () => {
       ).toEqual({});
     });
 
+    it('file - validates invalid size', () => {
+      const validationErrorMessages = [messages.maxSize.defaultMessage];
+      validationErrorMessages.title = 'file';
+
+      expect(
+        FormValidation.validateFieldsPerFieldset({
+          schema,
+          formData: { ...formData, file: { size: 10 } },
+          formatMessage,
+        }),
+      ).toEqual({
+        file: validationErrorMessages,
+      });
+    });
+
+    it('file - validates size', () => {
+      expect(
+        FormValidation.validateFieldsPerFieldset({
+          schema,
+          formData: { ...formData, file: { size: 1 } },
+          formatMessage,
+        }),
+      ).toEqual({});
+    });
+
+    it('notafile - the size validator does nothing', () => {
+      expect(
+        FormValidation.validateFieldsPerFieldset({
+          schema,
+          formData: { ...formData, notafile: { whatever: 1 } },
+          formatMessage,
+        }),
+      ).toEqual({});
+    });
+
     it('widget - validator from block - Fails', () => {
       let newSchema = {
         properties: {

package/src/helpers/FormValidation/validators.ts

@@ -1,5 +1,6 @@
 import { validationMessage } from '@plone/volto/helpers/FormValidation/FormValidation';
 import { messages } from '@plone/volto/helpers/MessageLabels/MessageLabels';
+import config from '@plone/volto/registry';
 
 type MinMaxValidator = {
   value: string | number;
@@ -15,6 +16,24 @@ type Validator = {
   formatMessage: Function;
 };
 
+type Choice = {
+  token: string;
+  label: string;
+};
+type ChoiceValidator = {
+  value: string | Choice;
+  field: Record<string, any>;
+  formData: any;
+  formatMessage: Function;
+};
+
+type FileValidator = {
+  value: Record<string, any>;
+  field: Record<string, any>;
+  formData: any;
+  formatMessage: Function;
+};
+
 export const isMaxPropertyValid = ({
   value,
   fieldSpec,
@@ -211,12 +230,26 @@ export const defaultLanguageControlPanelValidator = ({
   value,
   formData,
   formatMessage,
-}: Validator) => {
+}: ChoiceValidator) => {
+  const token = typeof value === 'object' ? value.token : value;
   const isValid =
-    value &&
+    token &&
     (formData.available_languages.find(
-      (lang: { token: string }) => lang.token === value,
+      (lang: { token: string }) => lang.token === token,
     ) ||
-      formData.available_languages.includes(value));
+      formData.available_languages.includes(token));
   return !isValid ? formatMessage(messages.defaultLanguage) : null;
 };
+
+export const sizeValidator = ({
+  value,
+  field,
+  formatMessage,
+}: FileValidator) => {
+  const maxSize = field.size
+    ? parseInt(field.size, 10)
+    : config.settings.maxFileUploadSize;
+  return maxSize && value.size > maxSize
+    ? formatMessage(messages.maxSize, { maxSize, size: value.size })
+    : null;
+};

package/src/helpers/MessageLabels/MessageLabels.js

@@ -25,6 +25,11 @@ export const messages = defineMessages({
     id: 'Maximum value is {len}.',
     defaultMessage: 'Maximum value is {len}.',
   },
+  maxSize: {
+    id: 'Maximum file size is {maxSize} bytes, but the uploaded file is {size} bytes.',
+    defaultMessage:
+      'Maximum file size is {maxSize} bytes, but the uploaded file is {size} bytes.',
+  },
   uniqueItems: {
     id: 'Items must be unique.',
     defaultMessage: 'Items must be unique.',

package/types/components/manage/Blocks/Block/Order/utilities.d.ts

@@ -1,8 +1,9 @@
 export function getProjection(items: any, activeId: any, overId: any, dragOffset: any, indentationWidth: any, arrayMove: any): {
+    parentId: any;
+    parentType: any;
     depth: any;
     maxDepth: any;
     minDepth: any;
-    parentId: any;
 };
 export function flattenTree(items: any): any;
 export function findItem(items: any, itemId: any): any;

package/types/components/theme/ConnectionRefused/ConnectionRefused.d.ts

@@ -1,2 +1,2 @@
-export default ConnectionRefused;
-declare function ConnectionRefused(): import("react/jsx-runtime").JSX.Element;
+declare const _default: (props: any) => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/types/components/theme/PasswordReset/PasswordReset.d.ts

@@ -1,2 +1,6 @@
-declare const _default: any;
-export default _default;
+export default PasswordReset;
+/**
+ * @function PasswordReset
+ * @returns {JSX.Element}
+ */
+declare function PasswordReset(): JSX.Element;

package/types/config/Views.d.ts

@@ -42,7 +42,7 @@ export const errorViews: {
     403: (props: any) => import("react/jsx-runtime").JSX.Element;
     408: () => string;
     500: (props: any) => import("react/jsx-runtime").JSX.Element;
-    ECONNREFUSED: () => import("react/jsx-runtime").JSX.Element;
+    ECONNREFUSED: (props: any) => import("react/jsx-runtime").JSX.Element;
     corsError: () => string;
 };
 export namespace layoutViewsNamesMapping {

package/types/helpers/Blocks/Blocks.d.ts

@@ -176,6 +176,7 @@ export function findBlocks(blocks: {}, types: any, result?: any[]): any[];
  */
 export function moveBlockEnhanced(formData: any, { source, destination }: number): any;
 export function getBlocks(properties: any): any[];
+export function getInvalidBlockLayoutIds(properties: any): string[];
 export function applyBlockInitialValue({ id, value, blocksConfig, formData, intl, }: {
     id: any;
     value: any;
@@ -193,3 +194,6 @@ export function getBlocksHierarchy(properties: any): any;
 export function findContainer(formData: object, { containerId }: {
     containerId: string;
 }): object | undefined;
+export function findParent(formData: object, { blockId }: {
+    blockId: string;
+}): object | undefined;

package/types/helpers/FormValidation/validators.d.ts

@@ -10,6 +10,22 @@ type Validator = {
     formData: any;
     formatMessage: Function;
 };
+type Choice = {
+    token: string;
+    label: string;
+};
+type ChoiceValidator = {
+    value: string | Choice;
+    field: Record<string, any>;
+    formData: any;
+    formatMessage: Function;
+};
+type FileValidator = {
+    value: Record<string, any>;
+    field: Record<string, any>;
+    formData: any;
+    formatMessage: Function;
+};
 export declare const isMaxPropertyValid: ({ value, fieldSpec, criterion, formatMessage, }: MinMaxValidator) => any;
 export declare const isMinPropertyValid: ({ value, fieldSpec, criterion, formatMessage, }: MinMaxValidator) => any;
 export declare const minLengthValidator: ({ value, field, formatMessage, }: Validator) => any;
@@ -26,5 +42,6 @@ export declare const endEventDateRangeValidator: ({ value, field, formData, form
 export declare const patternValidator: ({ value, field, formatMessage, }: Validator) => any;
 export declare const maxItemsValidator: ({ value, field, formatMessage, }: Validator) => any;
 export declare const minItemsValidator: ({ value, field, formatMessage, }: Validator) => any;
-export declare const defaultLanguageControlPanelValidator: ({ value, formData, formatMessage, }: Validator) => any;
+export declare const defaultLanguageControlPanelValidator: ({ value, formData, formatMessage, }: ChoiceValidator) => any;
+export declare const sizeValidator: ({ value, field, formatMessage, }: FileValidator) => any;
 export {};