@strapi/content-type-builder 5.54.0 → 5.55.1

package/dist/admin/src/components/ContentTypeBuilderNav/{useContentTypeBuilderMenu.d.ts → hooks/useContentTypeBuilderMenu.d.ts}

@@ -1,4 +1,14 @@
-import type { Status } from '../../types';
+import type { Status } from '../../../types';
+import type { SectionKey } from '../../DataManager/utils/contentStructure';
+import type { ContentTypeLink } from '../lib/buildFolderTree';
+export type FolderMenuSection = {
+    onCreateContentType: () => void;
+    links: ContentTypeLink[];
+    createTypeLabel: string;
+    section: SectionKey;
+    sectionId: string;
+    title: string;
+};
 type Link = {
     name: string;
     to: string;
@@ -10,7 +20,7 @@ type SubSection = {
     title: string;
     links: Link[];
 };
-type MenuSection = {
+export type FlatMenuSection = {
     name: string;
     title: {
         id: string;
@@ -24,13 +34,13 @@ type MenuSection = {
     links: Array<SubSection | Link>;
     linksCount?: number;
 };
-type Menu = MenuSection[];
-export declare const useContentTypeBuilderMenu: () => {
-    menu: Menu;
+export declare function useContentTypeBuilderMenu(): {
+    folderSections: FolderMenuSection[];
+    flatSections: FlatMenuSection[];
     search: {
-        value: string;
-        onChange: import("react").Dispatch<import("react").SetStateAction<string>>;
         clear: () => void;
+        onChange: import("react").Dispatch<import("react").SetStateAction<string>>;
+        value: string;
     };
 };
 export {};

package/dist/admin/src/components/ContentTypeBuilderNav/hooks/useFolderActions.d.ts

@@ -0,0 +1,42 @@
+import type { SectionKey } from '../../DataManager/utils/contentStructure';
+import type { UID } from '@strapi/types';
+export declare const useFolderActions: () => {
+    createFolder: (payload: {
+        section: SectionKey;
+        name: string;
+        parentId: string | null;
+    }) => void;
+    renameFolder: (payload: {
+        section: SectionKey;
+        id: string;
+        name: string;
+    }) => void;
+    moveFolder: (payload: {
+        section: SectionKey;
+        id: string;
+        newParentId: string | null;
+        index?: number;
+    }) => void;
+    deleteFolderOnly: (payload: {
+        section: SectionKey;
+        id: string;
+    }) => void;
+    deleteFolderAndContent: (payload: {
+        section: SectionKey;
+        id: string;
+        contentTypeUids: UID.ContentType[];
+    }) => void;
+    assignContentTypeToFolder: (payload: {
+        section: SectionKey;
+        uid: UID.ContentType;
+        targetGroupId: string | null;
+        index?: number;
+    }) => void;
+    reorderFolderChildren: (payload: {
+        section: SectionKey;
+        groupId: string;
+        from: number;
+        to: number;
+    }) => void;
+};
+export type FolderActions = ReturnType<typeof useFolderActions>;

package/dist/admin/src/components/ContentTypeBuilderNav/hooks/useSortableTree.d.ts

@@ -0,0 +1,53 @@
+import type { FolderTreeNode } from '../lib/buildFolderTree';
+import type { DropTarget } from '../lib/dropProjection';
+import type { FlatItem } from '../lib/flatModel';
+import type { CollisionDetection, DragMoveEvent, DragStartEvent, SensorDescriptor } from '@dnd-kit/core';
+import type { SortingStrategy } from '@dnd-kit/sortable';
+/** The insertion line to paint, plus the depth its left edge indents to. */
+export type DropLine = {
+    anchorId: string;
+    edge: 'top' | 'bottom';
+    depth: number;
+};
+interface UseSortableTreeOptions {
+    /** Commit a drop. Called only for a real move, with the node and its resolved target. */
+    onDrop: (activeNode: FolderTreeNode, target: DropTarget) => void;
+    /**
+     * Function which determines whether the dragged node may land on the resolved target.
+     */
+    canDrop?: (activeNode: FolderTreeNode, target: DropTarget) => boolean;
+    /** Spring-open a closed folder held under the pointer, so the user can drop deeper. */
+    onExpandFolder: (folderId: string) => void;
+    /** Ids of collapsed folders — used to tell a closed folder (springs open) from an empty one. */
+    collapsed: Set<string>;
+    /** When true the contentStructure tree is read-only. */
+    disabled: boolean;
+    /** The full flattened, visible tree (descendants of collapsed folders omitted). */
+    items: FlatItem[];
+}
+export interface UseSortableTreeResult {
+    collisionDetection: CollisionDetection;
+    sensors: SensorDescriptor<object>[];
+    sortingStrategy: SortingStrategy;
+    /** The items to render (the dragged folder's descendants are hidden mid-drag). */
+    renderedItems: FlatItem[];
+    /** The row being dragged, or null. */
+    activeItem: FlatItem | null;
+    /** Folder row (by dnd id) to highlight as the nest target — no line is drawn for it. */
+    dropTargetId: string | null;
+    /** The insertion line to paint, or null when nesting into a highlighted folder. */
+    dropLine: DropLine | null;
+    onDragStart: (event: DragStartEvent) => void;
+    onDragMove: (event: DragMoveEvent) => void;
+    onDragCancel: () => void;
+    onDragEnd: () => void;
+}
+/**
+ * The drag-and-drop engine for a flattened folder tree: it owns the drag state
+ * machine, pointer-vs-row geometry, spring-open timers and drop projection, and
+ * returns the props a `DndContext` + `SortableContext` need plus the resolved
+ * drop indicator. It carries no domain logic — nesting rules, the move itself,
+ * and expansion are supplied by the caller through {@link UseSortableTreeOptions}.
+ */
+export declare const useSortableTree: ({ onExpandFolder, collapsed, disabled, onDrop, canDrop, items, }: UseSortableTreeOptions) => UseSortableTreeResult;
+export {};

package/dist/admin/src/components/ContentTypeBuilderNav/lib/buildFolderTree.d.ts

@@ -0,0 +1,42 @@
+import type { Status } from '../../../types';
+import type { ContentStructureSection, GroupStatus } from '../../DataManager/utils/contentStructure';
+import type { UID } from '@strapi/types';
+export type ContentTypeLink = {
+    uid: UID.ContentType;
+    to: string;
+    title: string;
+    status: Status;
+};
+export type FolderNode = {
+    type: 'folder';
+    id: string;
+    name: string;
+    status: GroupStatus;
+    depth: number;
+    parentId: string | null;
+    children: FolderTreeNode[];
+};
+export type ContentTypeNode = {
+    type: 'contentType';
+    uid: UID.ContentType;
+    to: string;
+    title: string;
+    status: Status;
+    depth: number;
+    parentId: string | null;
+};
+export type FolderTreeNode = FolderNode | ContentTypeNode;
+export declare function buildSectionTree(section: ContentStructureSection, links: ContentTypeLink[], compareTitle: (a: string, b: string) => number): FolderTreeNode[];
+export declare function filterTree(nodes: FolderTreeNode[], matches: (text: string) => boolean): FolderTreeNode[];
+export declare function subtreeFolderHeight(folder: FolderNode): number;
+/**
+ * Whether moving `folder` under a target (a folder, or `null` for the section
+ * root) would keep the resulting subtree within {@link MAX_FOLDER_DEPTH}.
+ */
+export declare function canNestFolderAt(folder: FolderNode, target: FolderNode | null): boolean;
+export declare function countSubtree(section: ContentStructureSection, folderId: string, countableUids: ReadonlySet<UID.ContentType>): {
+    contentTypes: number;
+    subfolders: number;
+};
+export declare function collectSubtreeContentTypeUids(section: ContentStructureSection, folderId: string): UID.ContentType[];
+export declare function indexFolders(nodes: FolderTreeNode[]): Map<string, FolderNode>;

package/dist/admin/src/components/ContentTypeBuilderNav/lib/dropProjection.d.ts

@@ -0,0 +1,58 @@
+import type { FlatItem } from './flatModel';
+export declare const INDENT_WIDTH = 24;
+export type DropLine = {
+    edge: 'top' | 'bottom';
+    anchorId: string;
+};
+export type InsertTarget = {
+    parentId: string | null;
+    line: DropLine | null;
+    index: number;
+    depth: number;
+};
+export type DropTarget = {
+    kind: 'nest';
+    folderId: string;
+    depth: number;
+} | ({
+    kind: 'insert';
+} & InsertTarget);
+type DragState = {
+    activeId: string;
+    overId: string;
+    offsetX: number;
+    pointer?: {
+        x: number;
+        y: number;
+    };
+    overRect?: {
+        top: number;
+        height: number;
+    };
+};
+/**
+ * This resolved the destination for a drag-and-drop operation in the contentStructure tree. It takes into account the active item being dragged, the item it is being dropped over, the horizontal offset of the drag, and optionally which side of the target item the drop is intended for.
+ * It returns a DropTarget object that describes where the active item should be placed in relation to its siblings and parent in the tree structure.
+ *
+ * When the dragged row is over a non-folder row, the drop target is always a sibling of that row (and its destination is based on which half of the row the pointer is over).
+ *
+ * When the dragged row is over a folder row, the drop target can be either a sibling of that folder (if the pointer is over the top or bottom third of the row) or a child of that folder (if the pointer is over the middle third of the row).
+ * If the folder is collapsed, dropping into it will expand it and place the active row inside it.
+ *
+ * If the destination is nested such that the destination could be one of several depths, the depth is determined by the horizontal offset of the pointer.
+ *
+ * This allows for a user to position a row at the end of a folder, even if there are several expanded folders above the destination. Otherwise, this would be a multi-step operation.
+ *
+ */
+export declare function resolveDropTarget(items: FlatItem[], dragState: DragState): DropTarget | null;
+export type FolderDropZone = 'before' | 'nest' | 'after';
+type CalculateFolderDropZoneProps = {
+    itemBoundingBox: {
+        top: number;
+        height: number;
+    };
+    hasVisibleChildren: boolean;
+    pointerY: number;
+};
+export declare function calculateFolderDropZone({ hasVisibleChildren, itemBoundingBox, pointerY, }: CalculateFolderDropZoneProps): FolderDropZone;
+export {};

package/dist/admin/src/components/ContentTypeBuilderNav/lib/flatModel.d.ts

@@ -0,0 +1,18 @@
+import type { FolderTreeNode } from './buildFolderTree';
+export type FlatItem = {
+    parentId: string | null;
+    node: FolderTreeNode;
+    collapsed: boolean;
+    depth: number;
+    id: string;
+};
+export declare const itemId: (node: FolderTreeNode) => string;
+/**
+ * Flatten a contentStructure tree into visible, ordered rows. Descendants of a collapsed folder are omitted.
+ */
+export declare function flattenSortableTree(nodes: FolderTreeNode[], collapsed: Set<string>, parentId?: string | null, depth?: number): FlatItem[];
+/**
+ * Return a contentStructure without the active element's children.
+ * This is used to hide a dragged folder's descendants so it can't be dropped into its own subtree.
+ */
+export declare function removeSubtree(items: FlatItem[], activeId: string): FlatItem[];

package/dist/admin/src/components/DataManager/DataManagerContext.d.ts

@@ -1,3 +1,4 @@
+import type { ContentStructure, FolderSelection, SectionKey } from './utils/contentStructure';
 import type { Component, ContentType } from '../../types';
 import type { ComponentWithChildren } from './utils/retrieveComponentsThatHaveComponents';
 import type { NestedComponent } from './utils/retrieveNestedComponents';
@@ -56,6 +57,7 @@ export interface DataManagerContextValue {
             pluginOptions: Record<string, unknown>;
         };
         uid: Internal.UID.Schema;
+        folder?: FolderSelection;
     }) => void;
     changeDynamicZoneComponents: (opts: {
         forTarget: Struct.ModelType;
@@ -70,6 +72,44 @@ export interface DataManagerContextValue {
     }) => void;
     deleteComponent(uid: Internal.UID.Component): void;
     deleteContentType(uid: Internal.UID.ContentType): void;
+    contentStructure: ContentStructure;
+    createFolder: (opts: {
+        section: SectionKey;
+        name: string;
+        parentId: string | null;
+    }) => void;
+    renameFolder: (opts: {
+        section: SectionKey;
+        id: string;
+        name: string;
+    }) => void;
+    moveFolder: (opts: {
+        section: SectionKey;
+        id: string;
+        newParentId: string | null;
+        index?: number;
+    }) => void;
+    deleteFolderOnly: (opts: {
+        section: SectionKey;
+        id: string;
+    }) => void;
+    deleteFolderAndContent: (opts: {
+        section: SectionKey;
+        id: string;
+        contentTypeUids: Internal.UID.ContentType[];
+    }) => void;
+    assignContentTypeToFolder: (opts: {
+        section: SectionKey;
+        uid: Internal.UID.ContentType;
+        targetGroupId: string | null;
+        index?: number;
+    }) => void;
+    reorderFolderChildren: (opts: {
+        section: SectionKey;
+        groupId: string;
+        from: number;
+        to: number;
+    }) => void;
     removeComponentFromDynamicZone: (opts: {
         forTarget: Struct.ModelType;
         targetUid: Internal.UID.Schema;
@@ -106,6 +146,7 @@ export interface DataManagerContextValue {
             pluginOptions: Record<string, unknown>;
         };
         uid: Internal.UID.ContentType;
+        folder?: FolderSelection;
     }) => void;
     initialComponents: Record<Internal.UID.Component, Component>;
     components: Record<Internal.UID.Component, Component>;

package/dist/admin/src/components/DataManager/reducer.d.ts

@@ -1,10 +1,13 @@
 import type { Components, ContentTypes, ContentType, Component, AnyAttribute } from '../../types';
-import type { Internal, Struct } from '@strapi/types';
+import type { ContentStructure, SectionKey } from './utils/contentStructure';
+import type { Internal, Struct, UID } from '@strapi/types';
 export interface DataManagerStateType {
     components: Components;
     initialComponents: Components;
     contentTypes: ContentTypes;
     initialContentTypes: ContentTypes;
+    contentStructure: ContentStructure;
+    initialContentStructure: ContentStructure;
     reservedNames: {
         models: string[];
         attributes: string[];
@@ -21,6 +24,43 @@ type InitPayload = {
     components: Record<string, Component>;
     contentTypes: Record<string, ContentType>;
     reservedNames: DataManagerStateType['reservedNames'];
+    contentStructure?: ContentStructure;
+};
+type CreateFolderPayload = {
+    parentId: string | null;
+    section: SectionKey;
+    name: string;
+    id: string;
+};
+type RenameFolderPayload = {
+    section: SectionKey;
+    name: string;
+    id: string;
+};
+type MoveFolderPayload = {
+    newParentId: string | null;
+    section: SectionKey;
+    index?: number;
+    id: string;
+};
+type DeleteFolderPayload = {
+    section: SectionKey;
+    id: string;
+};
+type DeleteFolderAndContentPayload = DeleteFolderPayload & {
+    contentTypeUids: Internal.UID.ContentType[];
+};
+type AssignContentTypeToFolderPayload = {
+    targetGroupId: string | null;
+    uid: UID.ContentType;
+    section: SectionKey;
+    index?: number;
+};
+type ReorderFolderChildrenPayload = {
+    section: SectionKey;
+    groupId: string;
+    from: number;
+    to: number;
 };
 type AddAttributePayload = {
     attributeToSet: AttributeMutation;
@@ -52,6 +92,12 @@ type CreateComponentSchemaPayload = {
     };
     componentCategory: string;
 };
+type FolderAssignmentPayload = {
+    targetGroupId: string | null;
+} | {
+    newFolderId: string;
+    newFolderName: string;
+};
 type CreateSchemaPayload = {
     uid: string;
     data: {
@@ -62,6 +108,7 @@ type CreateSchemaPayload = {
         draftAndPublish: boolean;
         pluginOptions: PluginOptions;
     };
+    folder?: FolderAssignmentPayload;
 };
 type EditAttributePayload = {
     attributeToSet: AttributeMutation;
@@ -105,6 +152,7 @@ type UpdateSchemaPayload = {
         pluginOptions: PluginOptions;
     };
     uid: string;
+    folder?: FolderAssignmentPayload;
 };
 type MoveAttributePayload = {
     forTarget: Struct.ModelType;
@@ -182,6 +230,34 @@ declare const slice: import("@reduxjs/toolkit").Slice<import("./undoRedo").UndoR
         payload: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`;
         type: string;
     }>;
+    createFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: CreateFolderPayload;
+        type: string;
+    }>;
+    renameFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: RenameFolderPayload;
+        type: string;
+    }>;
+    moveFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: MoveFolderPayload;
+        type: string;
+    }>;
+    deleteFolderOnly: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: DeleteFolderPayload;
+        type: string;
+    }>;
+    deleteFolderAndContent: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: DeleteFolderAndContentPayload;
+        type: string;
+    }>;
+    assignContentTypeToFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: AssignContentTypeToFolderPayload;
+        type: string;
+    }>;
+    reorderFolderChildren: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: ReorderFolderChildrenPayload;
+        type: string;
+    }>;
     applyChange: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
         payload: {
             action: "add" | "update" | "delete";
@@ -266,6 +342,34 @@ export declare const reducer: import("redux").Reducer<import("./undoRedo").UndoR
         payload: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`;
         type: string;
     }>;
+    createFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: CreateFolderPayload;
+        type: string;
+    }>;
+    renameFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: RenameFolderPayload;
+        type: string;
+    }>;
+    moveFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: MoveFolderPayload;
+        type: string;
+    }>;
+    deleteFolderOnly: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: DeleteFolderPayload;
+        type: string;
+    }>;
+    deleteFolderAndContent: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: DeleteFolderAndContentPayload;
+        type: string;
+    }>;
+    assignContentTypeToFolder: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: AssignContentTypeToFolderPayload;
+        type: string;
+    }>;
+    reorderFolderChildren: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
+        payload: ReorderFolderChildrenPayload;
+        type: string;
+    }>;
     applyChange: import("@reduxjs/toolkit").CaseReducer<import("./undoRedo").UndoRedoState<DataManagerStateType>, {
         payload: {
             action: "add" | "update" | "delete";

package/dist/admin/src/components/DataManager/utils/cleanData.d.ts

@@ -1,3 +1,4 @@
+import type { ContentStructure } from './contentStructure';
 import type { Components, ContentTypes } from '../../../types';
 import type { UID } from '@strapi/types';
 declare const sortContentType: (types: ContentTypes) => {
@@ -22,11 +23,14 @@ type TrackingEventProperties = {
     editedFields: number;
     deletedFields: number;
 };
-declare const stateToRequestData: ({ components, contentTypes, }: {
+declare const stateToRequestData: ({ components, contentTypes, contentStructure, initialContentStructure, }: {
     components: Components;
     contentTypes: ContentTypes;
+    contentStructure?: ContentStructure;
+    initialContentStructure?: ContentStructure;
 }) => {
     requestData: {
+        contentStructure?: import("@strapi/types/dist/modules/content-structure.js").ContentStructureFile | undefined;
         components: ({
             action: string;
             uid: `${string}.${string}` | UID.ContentType;

package/dist/admin/src/components/DataManager/utils/contentStructure.d.ts

@@ -0,0 +1,68 @@
+import type { Status } from '../../../types';
+import type { Modules, Struct } from '@strapi/types';
+export type SectionKey = Modules.ContentStructure.ContentStructureSectionKey;
+export type ContentStructureChild = Modules.ContentStructure.ContentStructureChild;
+/**
+ * The status of a content structure group, excluding "REMOVED".
+ * The contentStructure API is declarative, so the server will identify removed groups by their absence in the submitted structure.
+ * The admin panel will remove groups from the tree upon deletion, so the "REMOVED" status is impossible to reach.
+ */
+export type GroupStatus = Exclude<Status, 'REMOVED'>;
+export type ContentStructureGroup = Modules.ContentStructure.ContentStructureGroup & {
+    status: GroupStatus;
+};
+export type ContentStructureSection = {
+    groups: ContentStructureGroup[];
+};
+export declare const CONTENT_STRUCTURE_VERSION = 1;
+export declare const MAX_FOLDER_DEPTH = 3;
+export type FolderSelection = {
+    targetGroupId: string | null;
+} | {
+    newFolderName: string;
+};
+/**
+ * Admin-side model of the content-structure (folder groups).
+ *
+ * The admin is identical to the server-side structure, but for the inclusion of a `status` field on every group.
+ * This allows the admin panel to track changes to the content structure using existing patterns.
+ *
+ * The `status` field is stripped by {@link toServerFile} before a client-modified structure is sent to the server.
+ */
+export type ContentStructure = {
+    version: typeof CONTENT_STRUCTURE_VERSION;
+    sections: Record<SectionKey, ContentStructureSection>;
+};
+export declare const SECTION_KEYS: readonly ["collectionTypes", "singleTypes"];
+export declare function sectionKeyForKind(kind: Struct.ContentTypeKind): SectionKey;
+export declare function createEmptyContentStructure(): ContentStructure;
+export declare function fromServerFile(file: Modules.ContentStructure.ContentStructureFile | null | undefined): ContentStructure;
+export declare function toServerFile(structure: ContentStructure): Modules.ContentStructure.ContentStructureFile;
+/**
+ * Determines whether two contentStructure trees differ in any way the server would persist.
+ *
+ * The client-side state manager removes groups from the tree upon deletion.
+ * This means that the "REMOVED" status is impossible to reach. See {@link GroupStatus}.
+ */
+export declare function hasContentStructureChanged(working: ContentStructure, initial: ContentStructure): boolean;
+export declare function generateGroupId(): string;
+/**
+ * Find a sibling folder that already has a given `name`.
+ *
+ * `excludeId` skips a group by id (used when renaming, so a folder doesn't
+ * collide with itself).
+ *
+ * Returns `undefined` for an empty name or no match.
+ */
+export declare function findSiblingFolderByName<TGroup extends Pick<ContentStructureGroup, 'id' | 'name' | 'parent'>>(groups: TGroup[], parentId: string | null, name: string, excludeId?: string): TGroup | undefined;
+/**
+ * Whether a folder name is already taken by a sibling. See
+ * {@link findSiblingFolderByName}.
+ */
+export declare function isFolderNameTakenBySibling(groups: Pick<ContentStructureGroup, 'id' | 'name' | 'parent'>[], parentId: string | null, name: string, excludeId?: string): boolean;
+/**
+ * Returns names that would collide if a folder were removed and its child folders inherited its
+ * parent. Both the existing destination siblings and the incoming children are compared using
+ * the same case-insensitive contract as create, rename, and move.
+ */
+export declare function getDeleteFolderOnlySiblingNameCollisions(groups: Pick<ContentStructureGroup, 'id' | 'name' | 'parent' | 'children'>[], groupId: string): string[];

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

@@ -0,0 +1,18 @@
+import type { FormChangeHandler, IntlLabel } from '../types';
+import type { FolderSelection } from './DataManager/utils/contentStructure';
+import type { Struct } from '@strapi/types';
+interface FolderSelectProps {
+    onChange: FormChangeHandler<FolderSelection | undefined, 'content-type-folder-select'>;
+    modifiedData?: {
+        kind?: Struct.ContentTypeKind;
+    };
+    value?: FolderSelection;
+    placeholder?: IntlLabel;
+    error?: string | null;
+    isCreating?: boolean;
+    intlLabel: IntlLabel;
+    targetUid?: string;
+    name: string;
+}
+export declare const FolderSelect: ({ error, modifiedData, placeholder, isCreating, intlLabel, targetUid, onChange, value, name, }: FolderSelectProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/FormModal/contentType/contentTypeForm.d.ts

@@ -40,16 +40,6 @@ export declare const contentTypeForm: {
                     };
                     name: string;
                     type: string;
-                    size?: undefined;
-                } | {
-                    type: string;
-                    size: number;
-                    intlLabel: {
-                        id: string;
-                        defaultMessage: string;
-                    };
-                    name: string;
-                    description?: undefined;
                 })[];
             }[];
         };
@@ -77,17 +67,6 @@ export declare const contentTypeForm: {
                     type: string;
                     size?: undefined;
                     radios?: undefined;
-                } | {
-                    type: string;
-                    size: number;
-                    intlLabel: {
-                        id: string;
-                        defaultMessage: string;
-                    };
-                    name: string;
-                    disabled?: undefined;
-                    description?: undefined;
-                    radios?: undefined;
                 } | {
                     intlLabel: {
                         id: string;

package/dist/admin/src/components/FormModal/forms/forms.d.ts

@@ -114,16 +114,6 @@ export declare const forms: {
                         };
                         name: string;
                         type: string;
-                        size?: undefined;
-                    } | {
-                        type: string;
-                        size: number;
-                        intlLabel: {
-                            id: string;
-                            defaultMessage: string;
-                        };
-                        name: string;
-                        description?: undefined;
                     })[];
                 }[];
             };

package/dist/admin/src/components/FormModal/reducer.d.ts

@@ -1,4 +1,5 @@
 import { type PayloadAction } from '@reduxjs/toolkit';
+import type { FolderSelection } from '../DataManager/utils/contentStructure';
 import type { Schema, Struct, UID } from '@strapi/types';
 import type { MessageDescriptor, PrimitiveType } from 'react-intl';
 type FormModalError = MessageDescriptor & {
@@ -22,6 +23,7 @@ export type FormModalData = Record<string, unknown> & {
     displayName?: string;
     draftAndPublish?: boolean;
     enum?: string[];
+    folder?: FolderSelection;
     icon?: string;
     kind?: Struct.ContentTypeKind;
     multiple?: boolean;
@@ -160,6 +162,11 @@ export declare const actions: import("@reduxjs/toolkit").CaseReducerActions<{
             displayName?: string | undefined;
             draftAndPublish?: boolean | undefined;
             enum?: string[] | undefined;
+            folder?: import("immer/dist/internal.js").WritableDraft<{
+                targetGroupId: string | null;
+            }> | import("immer/dist/internal.js").WritableDraft<{
+                newFolderName: string;
+            }> | undefined;
             icon?: string | undefined;
             kind?: Struct.ContentTypeKind | undefined;
             multiple?: boolean | undefined;