@strapi/content-type-builder 5.49.0 → 5.50.1

package/dist/admin/src/components/Relation/RelationNaturePicker/Components.d.ts

@@ -1,20 +1,19 @@
-/// <reference types="react" />
 import { BoxComponent, FlexComponent } from '@strapi/design-system';
 declare const Wrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
-    children?: import("react").ReactNode;
+    children?: React.ReactNode;
 } & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
     ref?: any;
 }, never> & Partial<Pick<Omit<import("@strapi/design-system").TransientBoxProps & {
-    children?: import("react").ReactNode;
+    children?: React.ReactNode;
 } & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
     ref?: any;
 }, never>>> & string & Omit<BoxComponent, keyof import("react").Component<any, {}, any>>;
 declare const IconWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
-    children?: import("react").ReactNode;
+    children?: React.ReactNode;
 } & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
@@ -22,7 +21,7 @@ declare const IconWrapper: import("styled-components/dist/types").IStyledCompone
 }, "$isSelected"> & {
     $isSelected: boolean;
 }, never> & Partial<Pick<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
-    children?: import("react").ReactNode;
+    children?: React.ReactNode;
 } & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
@@ -31,8 +30,8 @@ declare const IconWrapper: import("styled-components/dist/types").IStyledCompone
     $isSelected: boolean;
 }, never>>> & string & Omit<BoxComponent<"button">, keyof import("react").Component<any, {}, any>>;
 declare const InfosWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
-    ref?: ((instance: unknown) => void) | import("react").RefObject<unknown> | null | undefined;
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
 }, never> & Partial<Pick<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
-    ref?: ((instance: unknown) => void) | import("react").RefObject<unknown> | null | undefined;
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
 }, never>>> & string & Omit<FlexComponent, keyof import("react").Component<any, {}, any>>;
 export { IconWrapper, InfosWrapper, Wrapper };

package/dist/admin/src/components/SelectCategory.d.ts

@@ -1,18 +1,9 @@
+import type { FormChangeHandler, IntlLabel } from '../types';
 interface SelectCategoryProps {
     error?: string | null;
-    intlLabel: {
-        id: string;
-        defaultMessage: string;
-        values?: Record<string, any>;
-    };
+    intlLabel: IntlLabel;
     name: string;
-    onChange: (value: {
-        target: {
-            name: string;
-            value: any;
-            type: string;
-        };
-    }) => void;
+    onChange: FormChangeHandler<string, 'select-category'>;
     value?: string;
     isCreating?: boolean;
     dynamicZoneTarget?: string | null;

package/dist/admin/src/components/SelectComponent.d.ts

@@ -1,17 +1,18 @@
+import type { FormChangeHandler, IntlLabel } from '../types';
 import type { Internal } from '@strapi/types';
+type ComponentToCreate = {
+    displayName?: string;
+    category?: string;
+};
 interface SelectComponentProps {
-    componentToCreate?: Record<string, any> | null;
+    componentToCreate?: ComponentToCreate | null;
     error?: string | null;
-    intlLabel: {
-        id: string;
-        defaultMessage: string;
-        values?: Record<string, any>;
-    };
+    intlLabel: IntlLabel;
     isAddingAComponentToAnotherComponent: boolean;
     isCreating: boolean;
     isCreatingComponentWhileAddingAField: boolean;
     name: string;
-    onChange: (value: any) => void;
+    onChange: FormChangeHandler<string, 'select-category'>;
     targetUid: Internal.UID.Schema;
     value: string;
     forTarget: string;

package/dist/admin/src/components/SingularName.d.ts

@@ -1,16 +1,13 @@
-import type { IntlLabel } from '../types';
+import type { FormChangeHandler, IntlLabel } from '../types';
 interface SingularNameProps {
     description?: IntlLabel | null;
     error?: string | null;
     intlLabel: IntlLabel;
-    modifiedData: Record<string, any>;
+    modifiedData: {
+        displayName?: string;
+    };
     name: string;
-    onChange: (value: {
-        target: {
-            name: string;
-            value: string;
-        };
-    }) => void;
+    onChange: FormChangeHandler<string>;
     value?: string | null;
 }
 export declare const SingularName: ({ description, error, intlLabel, modifiedData, name, onChange, value, }: SingularNameProps) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/TabForm.d.ts

@@ -1,9 +1,40 @@
-interface TabFormProps {
-    form: Array<Record<string, any>>;
-    formErrors: Record<string, any>;
-    genericInputProps: Record<string, any>;
-    modifiedData: Record<string, any>;
-    onChange: (value: any) => void;
-}
+import { GenericInput } from './GenericInputs';
+import type { AnyAttribute, IntlLabel } from '../types';
+type FormInput = Partial<React.ComponentProps<typeof GenericInput>> & {
+    name: string;
+    type: string;
+    size?: number;
+};
+type FormSection = {
+    sectionTitle?: IntlLabel | null;
+    intlLabel?: IntlLabel;
+    items: FormInput[];
+};
+type FormError = {
+    id?: string;
+};
+type GenericInputProps = Record<string, unknown> & {
+    attributeName?: string;
+    contentTypeSchema?: {
+        attributes?: AnyAttribute[];
+    };
+};
+type ModifiedData = Record<string, unknown> & {
+    name?: string;
+};
+type TabFormChangeHandler = (value: {
+    target: {
+        name: string;
+        value?: unknown;
+        type?: string;
+    };
+}) => void;
+type TabFormProps = {
+    form: FormSection[];
+    formErrors: Record<string, FormError>;
+    genericInputProps: GenericInputProps;
+    modifiedData: ModifiedData;
+    onChange: TabFormChangeHandler;
+};
 export declare const TabForm: ({ form, formErrors, genericInputProps, modifiedData, onChange, }: TabFormProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/pages/ListView/LinkToCMSettingsView.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { Component, ContentType } from '../../types';
 interface LinkToCMSettingsViewProps {
     disabled: boolean;

package/dist/admin/src/types.d.ts

@@ -1,23 +1,32 @@
 import type { Schema, Struct, UID } from '@strapi/types';
+import type { PrimitiveType } from 'react-intl';
 export type IntlLabel = {
     id: string;
     defaultMessage: string;
-    values?: Record<string, any>;
+    values?: Record<string, PrimitiveType>;
 };
+export type FormChange<TValue = unknown, TType extends string = string> = {
+    target: {
+        name: string;
+        value?: TValue;
+        type?: TType;
+    };
+};
+export type FormChangeHandler<TValue = unknown, TType extends string = string> = (value: FormChange<TValue, TType>) => void;
 export type DifferentAttributesKind = 'Populatable' | 'NonPopulatable' | 'Any';
 export type Status = 'UNCHANGED' | 'CHANGED' | 'REMOVED' | 'NEW';
-type Schema = {
-    modelType: Struct.ModelType;
-    attributes: any[];
-    [key: string]: any;
+export type AttributeConditionValue = string | number | boolean;
+export type AttributeConditionRule = [{
+    var: string;
+}, AttributeConditionValue];
+export type AttributeConditions = {
+    visible?: Record<string, AttributeConditionRule>;
 };
 export type Base = {
     name: string;
     status?: Status;
-    customField?: any;
-    conditions?: {
-        visible?: Record<string, any>;
-    };
+    customField?: string;
+    conditions?: AttributeConditions;
 };
 export type Relation = Base & {
     type: 'relation';
@@ -26,7 +35,7 @@ export type Relation = Base & {
     targetAttribute?: string | null;
     configurable?: boolean;
     private?: boolean;
-    pluginOptions?: Record<string, any>;
+    pluginOptions?: Record<string, unknown>;
 };
 export type Media = Base & {
     type: 'media';
@@ -35,7 +44,7 @@ export type Media = Base & {
     configurable?: boolean;
     private?: boolean;
     allowedTypes?: string[];
-    pluginOptions?: Record<string, any>;
+    pluginOptions?: Record<string, unknown>;
 };
 export type AnyAttribute = Base & (Schema.Attribute.BigInteger | Schema.Attribute.Boolean | Schema.Attribute.Blocks | Schema.Attribute.Component<UID.Component, boolean> | Schema.Attribute.DateTime | Schema.Attribute.Date | Schema.Attribute.Decimal | Schema.Attribute.DynamicZone | Schema.Attribute.Email | Schema.Attribute.Enumeration<string[]> | Schema.Attribute.Float | Schema.Attribute.Integer | Schema.Attribute.JSON | Schema.Attribute.Password | Schema.Attribute.RichText | Schema.Attribute.String | Schema.Attribute.Text | Schema.Attribute.Time | Schema.Attribute.Timestamp | Schema.Attribute.UID | Media | Relation);
 export type Component = Omit<Struct.ComponentSchema, 'attributes'> & {
@@ -51,4 +60,3 @@ export type ContentType = Omit<Struct.ContentTypeSchema, 'attributes'> & {
 };
 export type Components = Record<string, Component>;
 export type ContentTypes = Record<string, ContentType>;
-export {};

package/dist/admin/src/utils/conditions.d.ts

@@ -1,17 +1,26 @@
-import type { AnyAttribute } from '../types';
+import type { AnyAttribute, AttributeConditionValue, AttributeConditions, ContentTypes } from '../types';
 interface DependentRow {
     contentTypeUid: string;
     contentType: string;
     attribute: string;
 }
-export declare const checkDependentRows: (contentTypes: Record<string, any>, fieldName: string) => DependentRow[];
-export declare const formatCondition: (condition: any, availableFields: Array<{
+type VisibleConditionEntry = {
+    operator: string;
+    fieldVar: {
+        var: string;
+    };
+    value: AttributeConditionValue;
+};
+export declare const getVisibleConditionEntries: (condition?: AttributeConditions | null) => VisibleConditionEntry[];
+export declare const getFirstVisibleConditionEntry: (condition?: AttributeConditions | null) => VisibleConditionEntry;
+export declare const checkDependentRows: (contentTypes: ContentTypes, fieldName: string) => DependentRow[];
+export declare const formatCondition: (condition: AttributeConditions, availableFields: Array<{
     name: string;
     type: string;
 }>, attributeName: string) => string;
 export declare const getAvailableConditionFields: (attributes: AnyAttribute[], currentFieldName: string) => {
     name: string;
-    type: "string" | "boolean" | "time" | "text" | "media" | "date" | "email" | "password" | "decimal" | "component" | "relation" | "biginteger" | "blocks" | "datetime" | "dynamiczone" | "enumeration" | "float" | "integer" | "json" | "richtext" | "timestamp" | "uid";
+    type: "string" | "boolean" | "time" | "text" | "media" | "date" | "email" | "password" | "decimal" | "relation" | "biginteger" | "blocks" | "component" | "datetime" | "dynamiczone" | "enumeration" | "float" | "integer" | "json" | "richtext" | "timestamp" | "uid";
     enum: string[] | undefined;
 }[];
 export {};

package/dist/admin/src/utils/formAPI.d.ts

@@ -1,43 +1,48 @@
-export interface FormAPI {
+import * as yup from 'yup';
+type YupObjectShape = Parameters<ReturnType<typeof yup.object>['shape']>[0];
+type YupObjectSchema = ReturnType<typeof yup.object>;
+type FormSection = unknown;
+type FormExtensionHandler = (props?: unknown) => FormSection[];
+type FormValidator = (args: unknown[]) => YupObjectShape;
+type ContentTypeSchemaMutation = (data: Record<string, unknown>, initialData: Record<string, unknown>) => Record<string, unknown>;
+type ExtensionForm = {
+    advanced: FormExtensionHandler[];
+    base: FormExtensionHandler[];
+};
+type ExtensionDefinition = {
+    validators: FormValidator[];
+    form: ExtensionForm;
+};
+type ExtensionInput = {
+    validator?: FormValidator;
+    form: {
+        advanced: FormExtensionHandler;
+        base: FormExtensionHandler;
+    };
+};
+export type FormAPI = {
     components: {
-        inputs: Record<string, any>;
+        inputs: Record<string, unknown>;
         add: ({ id, component }: {
             id: string;
-            component: any;
+            component: unknown;
         }) => void;
     };
     types: {
         attribute: {
-            [key: string]: {
-                validators: any[];
-                form: {
-                    advanced: any[];
-                    base: any[];
-                };
-            };
-        };
-        contentType: {
-            validators: any[];
-            form: {
-                advanced: any[];
-                base: any[];
-            };
-        };
-        component: {
-            validators: any[];
-            form: {
-                advanced: any[];
-                base: any[];
-            };
+            [key: string]: ExtensionDefinition;
         };
+        contentType: ExtensionDefinition;
+        component: ExtensionDefinition;
     };
-    contentTypeSchemaMutations: any[];
-    addContentTypeSchemaMutation: (cb: any) => void;
-    extendContentType: (data: any) => void;
-    extendFields: (fields: any[], data: any) => void;
-    getAdvancedForm: (target: any, props?: any) => any[];
-    makeCustomFieldValidator: (attributeShape: any, validator: any, ...validatorArgs: any) => any;
-    makeValidator: (target: any, initShape: any, ...args: any) => any;
-    mutateContentTypeSchema: (data: Record<string, unknown>, initialData: Record<string, unknown>) => any;
-}
+    contentTypeSchemaMutations: ContentTypeSchemaMutation[];
+    addContentTypeSchemaMutation: (cb: ContentTypeSchemaMutation) => void;
+    extendContentType: (data: ExtensionInput) => void;
+    extendFields: (fields: string[], data: ExtensionInput) => void;
+    getAdvancedForm: (target: string[], props?: unknown) => FormSection[];
+    makeCustomFieldValidator: (attributeShape: YupObjectSchema, validator: FormValidator | undefined, ...validatorArgs: unknown[]) => YupObjectSchema;
+    makeValidator: (target: string[], initShape: YupObjectSchema, ...args: unknown[]) => YupObjectSchema;
+    mutateContentTypeSchema: (data: Record<string, unknown>, initialData: Record<string, unknown>) => Record<string, unknown>;
+};
 export declare const formsAPI: FormAPI;
+export {};

package/dist/admin/src/utils/getRelationType.d.ts

@@ -3,4 +3,4 @@ import type { Schema } from '@strapi/types';
  *
  * Retrieves the relation type
  */
-export declare const getRelationType: (relation: Schema.Attribute.RelationKind.Any, targetAttribute?: string | null) => Schema.Attribute.RelationKind.Any;
+export declare const getRelationType: (relation?: Schema.Attribute.RelationKind.Any, targetAttribute?: string | null) => "oneToOne" | "oneToMany" | "manyToOne" | "manyToMany" | Schema.Attribute.RelationKind.Morph | "oneWay" | "manyWay" | undefined;

package/dist/admin/src/utils/isAllowedContentTypesForRelations.d.ts

@@ -1,2 +1,2 @@
 import type { ContentType } from '../types';
-export declare const isAllowedContentTypesForRelations: (contentType: Partial<Pick<ContentType, 'kind' | 'restrictRelationsTo'>>) => boolean;
+export declare const isAllowedContentTypesForRelations: (contentType: Partial<Pick<ContentType, "kind" | "restrictRelationsTo">>) => boolean;

package/dist/admin/src/utils/parseNumberInputValue.d.ts

@@ -0,0 +1 @@
+export declare const parseNumberInputValue: (value: string | number | null | undefined) => number;

package/dist/admin/translations/en.json.js

@@ -68,6 +68,7 @@ var en = {
     "error.contentType.pluralName-equals-singularName": "This value cannot be the same as the Singular API ID of another content type.",
     "error.contentType.pluralName-equals-collectionName": "This value is already in use by another content type.",
     "error.contentTypeName.reserved-name": "This name cannot be used in your project as it might break other functionalities",
+    "error.category.format": "A category name must start with a letter and only contain letters, numbers, dashes and underscores",
     "error.validation.enum-duplicate": "Duplicate values are not allowed (only alphanumeric characters are taken into account).",
     "error.validation.enum-empty-string": "Empty strings are not allowed",
     "error.validation.enum-regex": "At least one value is invalid. Values should have at least one alphabetical character preceding the first occurence of a number.",

package/dist/admin/translations/en.json.js.map

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

package/dist/admin/translations/en.json.mjs

@@ -64,6 +64,7 @@ var en = {
     "error.contentType.pluralName-equals-singularName": "This value cannot be the same as the Singular API ID of another content type.",
     "error.contentType.pluralName-equals-collectionName": "This value is already in use by another content type.",
     "error.contentTypeName.reserved-name": "This name cannot be used in your project as it might break other functionalities",
+    "error.category.format": "A category name must start with a letter and only contain letters, numbers, dashes and underscores",
     "error.validation.enum-duplicate": "Duplicate values are not allowed (only alphanumeric characters are taken into account).",
     "error.validation.enum-empty-string": "Empty strings are not allowed",
     "error.validation.enum-regex": "At least one value is invalid. Values should have at least one alphabetical character preceding the first occurence of a number.",

package/dist/admin/translations/en.json.mjs.map

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