@umbraco-cms/backoffice 14.0.0-bd6f74b3 → 14.0.0-c074e160

package/dist-cms/mocks/data/scripts.data.d.ts

@@ -0,0 +1,21 @@
+import { UmbData } from './data.js';
+import { CreatePathFolderRequestModel, CreateTextFileViewModelBaseModel, FileSystemTreeItemPresentationModel, PagedFileSystemTreeItemPresentationModel, ScriptItemResponseModel, ScriptResponseModel, UpdateScriptRequestModel } from '../../external/backend-api/index.js';
+type ScriptsDataItem = ScriptResponseModel & FileSystemTreeItemPresentationModel;
+export declare const data: Array<ScriptsDataItem>;
+declare class UmbScriptsData extends UmbData<ScriptsDataItem> {
+    constructor();
+    getTreeRoot(): PagedFileSystemTreeItemPresentationModel;
+    getTreeItemChildren(parentPath: string): PagedFileSystemTreeItemPresentationModel;
+    getTreeItem(paths: Array<string>): Array<FileSystemTreeItemPresentationModel>;
+    getItem(paths: Array<string>): Array<ScriptItemResponseModel>;
+    getFolder(path: string): FileSystemTreeItemPresentationModel;
+    postFolder(payload: CreatePathFolderRequestModel): ScriptsDataItem;
+    deleteFolder(path: string): (string | undefined)[];
+    getScript(path: string): ScriptResponseModel | undefined;
+    insertScript(item: CreateTextFileViewModelBaseModel): ScriptsDataItem;
+    insert(item: ScriptsDataItem): ScriptsDataItem;
+    updateData(updateItem: UpdateScriptRequestModel): void;
+    delete(paths: Array<string>): (string | undefined)[];
+}
+export declare const umbScriptsData: UmbScriptsData;
+export {};

package/dist-cms/mocks/data/scripts.data.js

@@ -0,0 +1,205 @@
+import { UmbData } from './data.js';
+import { createFileItemResponseModelBaseModel, createFileSystemTreeItem, createTextFileItem } from './utils.js';
+export const data = [
+    {
+        path: 'some-folder',
+        isFolder: true,
+        name: 'some-folder',
+        type: 'script',
+        hasChildren: true,
+    },
+    {
+        path: 'another-folder',
+        isFolder: true,
+        name: 'another-folder',
+        type: 'script',
+        hasChildren: true,
+    },
+    {
+        path: 'very important folder',
+        isFolder: true,
+        name: 'very important folder',
+        type: 'script',
+        hasChildren: true,
+    },
+    {
+        path: 'some-folder/ugly script.js',
+        isFolder: false,
+        name: 'ugly script.js',
+        type: 'script',
+        hasChildren: false,
+        content: `function makeid(length) {
+			var result           = '';
+			var characters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+			var charactersLength = characters.length;
+			for ( var i = 0; i < length; i++ ) {
+			   result += characters.charAt(Math.floor(Math.random() * charactersLength));
+			}
+			return result;
+		 }
+		 
+		 console.log(makeid(5));`,
+    },
+    {
+        path: 'some-folder/nice script.js',
+        isFolder: false,
+        name: 'nice script.js',
+        type: 'script',
+        hasChildren: false,
+        content: `var items = {
+			"item_1": "1",
+			"item_2": "2",
+			"item_3": "3"
+		}
+		for (var item in items) {
+			console.log(items[item]);
+		}`,
+    },
+    {
+        path: 'another-folder/only bugs.js',
+        isFolder: false,
+        name: 'only bugs.js',
+        type: 'script',
+        hasChildren: false,
+        content: `var my_arr = [4, '', 0, 10, 7, '', false, 10];
+
+		my_arr = my_arr.filter(Boolean);
+		
+		console.log(my_arr);`,
+    },
+    {
+        path: 'very important folder/no bugs at all.js',
+        isFolder: false,
+        name: 'no bugs at all.js',
+        type: 'script',
+        hasChildren: false,
+        content: `const date_str = "07/20/2021";
+		const date = new Date(date_str);
+		const full_day_name = date.toLocaleDateString('default', { weekday: 'long' });
+		// -> to get full day name e.g. Tuesday
+		
+		const short_day_name = date.toLocaleDateString('default', { weekday: 'short' });
+		console.log(short_day_name);
+		// -> TO get the short day name e.g. Tue`,
+    },
+    {
+        path: 'very important folder/nope.js',
+        isFolder: false,
+        name: 'nope.js',
+        type: 'script',
+        hasChildren: false,
+        content: `// Define an object
+		const employee = {
+			"name": "John Deo",
+			"department": "IT",
+			"project": "Inventory Manager"
+		};
+		
+		// Remove a property
+		delete employee["project"];
+		
+		console.log(employee);`,
+    },
+];
+class UmbScriptsData extends UmbData {
+    constructor() {
+        super(data);
+    }
+    getTreeRoot() {
+        const items = this.data.filter((item) => item.path?.includes('/') === false);
+        const treeItems = items.map((item) => createFileSystemTreeItem(item));
+        const total = items.length;
+        return { items: treeItems, total };
+    }
+    getTreeItemChildren(parentPath) {
+        const items = this.data.filter((item) => item.path?.startsWith(parentPath));
+        const treeItems = items.map((item) => createFileSystemTreeItem(item));
+        const total = items.length;
+        return { items: treeItems, total };
+    }
+    getTreeItem(paths) {
+        const items = this.data.filter((item) => paths.includes(item.path ?? ''));
+        return items.map((item) => createFileSystemTreeItem(item));
+    }
+    getItem(paths) {
+        const items = this.data.filter((item) => paths.includes(item.path ?? ''));
+        return items.map((item) => createFileItemResponseModelBaseModel(item));
+    }
+    getFolder(path) {
+        const items = data.filter((item) => item.isFolder && item.path === path);
+        return items;
+    }
+    postFolder(payload) {
+        const newFolder = {
+            path: `${payload.parentPath ?? ''}/${payload.name}`,
+            isFolder: true,
+            name: payload.name,
+            type: 'script',
+            hasChildren: false,
+        };
+        return this.insert(newFolder);
+    }
+    deleteFolder(path) {
+        return this.delete([path]);
+    }
+    getScript(path) {
+        return createTextFileItem(this.data.find((item) => item.path === path));
+    }
+    insertScript(item) {
+        const newItem = {
+            ...item,
+            path: `${item.parentPath}/${item.name}.js}`,
+            isFolder: false,
+            hasChildren: false,
+            type: 'script',
+        };
+        this.insert(newItem);
+        return newItem;
+    }
+    insert(item) {
+        const exits = this.data.find((i) => i.path === item.path);
+        if (exits) {
+            throw new Error(`Item with path ${item.path} already exists`);
+        }
+        this.data.push(item);
+        return item;
+    }
+    updateData(updateItem) {
+        const itemIndex = this.data.findIndex((item) => item.path === updateItem.existingPath);
+        const item = this.data[itemIndex];
+        if (!item)
+            return;
+        // TODO: revisit this code, seems like something we can solve smarter/type safer now:
+        const itemKeys = Object.keys(item);
+        const newItem = { ...item };
+        for (const [key] of Object.entries(updateItem)) {
+            if (itemKeys.indexOf(key) !== -1) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                newItem[key] = updateItem[key];
+            }
+        }
+        // Specific to fileSystem, we need to update path based on name:
+        const dirName = updateItem.existingPath?.substring(0, updateItem.existingPath.lastIndexOf('/'));
+        newItem.path = `${dirName}${dirName ? '/' : ''}${updateItem.name}`;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.data[itemIndex] = newItem;
+    }
+    delete(paths) {
+        const pathsOfItemsToDelete = this.data
+            .filter((item) => {
+            if (!item.path)
+                throw new Error('Item has no path');
+            return paths.includes(item.path);
+        })
+            .map((item) => item.path);
+        this.data = this.data.filter((item) => {
+            if (!item.path)
+                throw new Error('Item has no path');
+            return paths.indexOf(item.path) === -1;
+        });
+        return pathsOfItemsToDelete;
+    }
+}
+export const umbScriptsData = new UmbScriptsData();

package/dist-cms/mocks/data/stylesheet.data.d.ts

@@ -1,14 +1,36 @@
-import { UmbEntityData } from './entity.data.js';
-import { FileSystemTreeItemPresentationModel, PagedFileSystemTreeItemPresentationModel } from '../../external/backend-api/index.js';
-type StylesheetDBItem = FileSystemTreeItemPresentationModel & {
-    content: string;
+import { UmbData } from './data.js';
+import { CreateTextFileViewModelBaseModel, ExtractRichTextStylesheetRulesRequestModel, ExtractRichTextStylesheetRulesResponseModel, FileSystemTreeItemPresentationModel, InterpolateRichTextStylesheetRequestModel, PagedFileSystemTreeItemPresentationModel, PagedStylesheetOverviewResponseModel, StylesheetResponseModel, UpdateStylesheetRequestModel } from '../../external/backend-api/index.js';
+type StylesheetDBItem = StylesheetResponseModel & FileSystemTreeItemPresentationModel & {
+    icon?: string;
 };
 export declare const data: Array<StylesheetDBItem>;
-declare class UmbStylesheetData extends UmbEntityData<StylesheetDBItem> {
+declare class UmbStylesheetData extends UmbData<StylesheetDBItem> {
     constructor();
     getTreeRoot(): PagedFileSystemTreeItemPresentationModel;
     getTreeItemChildren(parentPath: string): PagedFileSystemTreeItemPresentationModel;
     getTreeItem(paths: Array<string>): Array<FileSystemTreeItemPresentationModel>;
+    getStylesheetItem(path: string): StylesheetDBItem | undefined;
+    getStylesheet(path: string): StylesheetResponseModel | undefined;
+    getAllStylesheets(): PagedStylesheetOverviewResponseModel;
+    getFolder(path: string): StylesheetDBItem | undefined;
+    getRules(path: string): ExtractRichTextStylesheetRulesResponseModel;
+    extractRules({ requestBody }: {
+        requestBody?: ExtractRichTextStylesheetRulesRequestModel;
+    }): Promise<{
+        rules: ({
+            [key: string]: string;
+        } | undefined)[];
+    }>;
+    interpolateRules({ requestBody }: {
+        requestBody?: InterpolateRichTextStylesheetRequestModel;
+    }): {
+        content: string;
+    };
+    insertFolder(item: CreateTextFileViewModelBaseModel): StylesheetDBItem;
+    insertStyleSheet(item: CreateTextFileViewModelBaseModel): StylesheetDBItem;
+    insert(item: StylesheetDBItem): StylesheetDBItem;
+    updateData(updateItem: UpdateStylesheetRequestModel): void;
+    delete(paths: Array<string>): (string | undefined)[];
 }
 export declare const umbStylesheetData: UmbStylesheetData;
 export {};

package/dist-cms/mocks/data/stylesheet.data.js

@@ -1,44 +1,102 @@
-import { UmbEntityData } from './entity.data.js';
-import { createFileSystemTreeItem } from './utils.js';
+import { UmbData } from './data.js';
+import { createFileSystemTreeItem, createFileItemResponseModelBaseModel, createTextFileItem } from './utils.js';
 export const data = [
     {
         path: 'Stylesheet File 1.css',
+        icon: 'style',
         isFolder: false,
         name: 'Stylesheet File 1.css',
         type: 'stylesheet',
         hasChildren: false,
-        content: `Stylesheet content 1`,
+        content: `
+		/** Stylesheet 1 */
+
+		h1 {
+	color: blue;
+}
+
+/**umb_name:bjjh*/
+h1 {
+	color: blue;
+}
+
+/**umb_name:comeone*/
+h1 {
+	color: blue;
+}
+
+/**umb_name:lol*/
+h1 {
+	color: blue;
+}`,
     },
     {
         path: 'Stylesheet File 2.css',
         isFolder: false,
+        icon: 'style',
         name: 'Stylesheet File 2.css',
         type: 'stylesheet',
         hasChildren: false,
-        content: `Stylesheet content 2`,
+        content: `
+		/** Stylesheet 2 */
+h1 {
+	color: green;
+}
+
+/**umb_name:HELLO*/
+h1 {
+	color: green;
+}
+
+/**umb_name:SOMETHING*/
+h1 {
+	color: green;
+}
+
+/**umb_name:NIOCE*/
+h1 {
+	color: green;
+}`,
     },
     {
         path: 'Folder 1',
-        isFolder: true,
         name: 'Folder 1',
+        isFolder: true,
+        icon: 'folder',
         type: 'stylesheet',
         hasChildren: true,
-        content: `Stylesheet content 3`,
     },
     {
         path: 'Folder 1/Stylesheet File 3.css',
-        isFolder: false,
         name: 'Stylesheet File 3.css',
         type: 'stylesheet',
-        hasChildren: false,
-        content: `Stylesheet content 3`,
+        hasChildren: true,
+        isFolder: false,
+        content: `h1 {
+	color: pink;
+}
+
+/**umb_name:ONE*/
+h1 {
+	color: pink;
+}
+
+/**umb_name:TWO*/
+h1 {
+	color: pink;
+}
+
+/**umb_name:THREE*/
+h1 {
+	color: pink;
+}`,
     },
 ];
 // Temp mocked database
 // TODO: all properties are optional in the server schema. I don't think this is correct.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
-class UmbStylesheetData extends UmbEntityData {
+class UmbStylesheetData extends UmbData {
     constructor() {
         super(data);
     }
@@ -58,5 +116,134 @@ class UmbStylesheetData extends UmbEntityData {
         const items = this.data.filter((item) => paths.includes(item.path ?? ''));
         return items.map((item) => createFileSystemTreeItem(item));
     }
+    getStylesheetItem(path) {
+        return createFileItemResponseModelBaseModel(this.data.find((item) => item.path === path));
+    }
+    getStylesheet(path) {
+        return createTextFileItem(this.data.find((item) => item.path === path));
+    }
+    getAllStylesheets() {
+        return {
+            items: this.data.map((item) => createTextFileItem(item)),
+            total: this.data.map((item) => !item.isFolder).length,
+        };
+    }
+    getFolder(path) {
+        return this.data.find((item) => item.path === path && item.isFolder === true);
+    }
+    getRules(path) {
+        const regex = /\*\*\s*umb_name:\s*(?<name>[^*\r\n]*?)\s*\*\/\s*(?<selector>[^,{]*?)\s*{\s*(?<styles>.*?)\s*}/gis;
+        const item = this.data.find((item) => item.path === path);
+        if (!item)
+            throw Error('item not found');
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        //@ts-ignore
+        // eslint-disable-next-line no-unsafe-optional-chaining
+        const rules = [...item.content?.matchAll(regex)].map((match) => match.groups);
+        return { rules };
+    }
+    async extractRules({ requestBody }) {
+        const regex = /\*\*\s*umb_name:\s*(?<name>[^*\r\n]*?)\s*\*\/\s*(?<selector>[^,{]*?)\s*{\s*(?<styles>.*?)\s*}/gis;
+        if (!requestBody) {
+            throw Error('No request body');
+        }
+        const { content } = await requestBody;
+        if (!content)
+            return { rules: [] };
+        const rules = [...content.matchAll(regex)].map((match) => match.groups);
+        return { rules };
+    }
+    interpolateRules({ requestBody }) {
+        const regex = /\/\*\*\s*umb_name:\s*(?<name>[^*\r\n]*?)\s*\*\/\s*(?<selector>[^,{]*?)\s*{\s*(?<styles>.*?)\s*}/gis;
+        if (!requestBody) {
+            throw Error('No request body');
+        }
+        const { content, rules } = requestBody;
+        if (!content && !rules)
+            return { content: '' };
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        //@ts-ignore
+        const cleanedContent = content?.replaceAll(regex, '');
+        const newContent = `${cleanedContent.replace(/[\r\n]+$/, '')}
+
+${rules
+            ?.map((rule) => `/**umb_name:${rule.name}*/
+${rule.selector} {
+	${rule.styles}
+}
+
+`)
+            .join('')}`;
+        return { content: newContent };
+    }
+    insertFolder(item) {
+        const newItem = {
+            ...item,
+            path: `${item.parentPath}/${item.name}`,
+            isFolder: true,
+            hasChildren: false,
+            type: 'stylesheet',
+            icon: 'folder',
+        };
+        this.insert(newItem);
+        return newItem;
+    }
+    insertStyleSheet(item) {
+        const newItem = {
+            ...item,
+            path: `${item.parentPath}/${item.name}.css`,
+            isFolder: false,
+            hasChildren: false,
+            type: 'stylesheet',
+            icon: 'style',
+        };
+        this.insert(newItem);
+        return newItem;
+    }
+    insert(item) {
+        const exits = this.data.find((i) => i.path === item.path);
+        if (exits) {
+            throw new Error(`Item with path ${item.path} already exists`);
+        }
+        this.data.push(item);
+        return item;
+    }
+    updateData(updateItem) {
+        const itemIndex = this.data.findIndex((item) => item.path === updateItem.existingPath);
+        const item = this.data[itemIndex];
+        if (!item)
+            return;
+        // TODO: revisit this code, seems like something we can solve smarter/type safer now:
+        const itemKeys = Object.keys(item);
+        const newItem = { ...item };
+        for (const [key] of Object.entries(updateItem)) {
+            if (itemKeys.indexOf(key) !== -1) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                newItem[key] = updateItem[key];
+            }
+        }
+        // Specific to fileSystem, we need to update path based on name:
+        const dirName = updateItem.existingPath?.substring(0, updateItem.existingPath.lastIndexOf('/'));
+        newItem.path = `${dirName}${dirName ? '/' : ''}${updateItem.name}`;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.data[itemIndex] = newItem;
+    }
+    delete(paths) {
+        const deletedPaths = this.data
+            .filter((item) => {
+            if (!item.path)
+                throw new Error('Item has no path');
+            paths.includes(item.path);
+        })
+            .map((item) => item.path);
+        this.data = this.data.filter((item) => {
+            if (!item.path)
+                throw new Error('Item has no path');
+            paths.indexOf(item.path) === -1;
+        });
+        return deletedPaths;
+    }
 }
 export const umbStylesheetData = new UmbStylesheetData();

package/dist-cms/mocks/data/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ContentTreeItemResponseModel, DocumentTreeItemResponseModel, DocumentTypeTreeItemResponseModel, EntityTreeItemResponseModel, FolderTreeItemResponseModel, DocumentTypeResponseModel, FileSystemTreeItemPresentationModel, DocumentResponseModel, TextFileResponseModelBaseModel } from '../../external/backend-api/index.js';
+import type { ContentTreeItemResponseModel, DocumentTreeItemResponseModel, DocumentTypeTreeItemResponseModel, EntityTreeItemResponseModel, FolderTreeItemResponseModel, DocumentTypeResponseModel, FileSystemTreeItemPresentationModel, DocumentResponseModel, TextFileResponseModelBaseModel, FileItemResponseModelBaseModel } from '../../external/backend-api/index.js';
 export declare const createEntityTreeItem: (item: any) => EntityTreeItemResponseModel;
 export declare const createFolderTreeItem: (item: any) => FolderTreeItemResponseModel;
 export declare const createContentTreeItem: (item: any) => ContentTreeItemResponseModel & {
@@ -10,3 +10,4 @@ export declare const createDocumentTreeItem: (item: DocumentResponseModel) => Do
 export declare const createDocumentTypeTreeItem: (item: DocumentTypeResponseModel) => DocumentTypeTreeItemResponseModel;
 export declare const createFileSystemTreeItem: (item: any) => FileSystemTreeItemPresentationModel;
 export declare const createTextFileItem: (item: any) => TextFileResponseModelBaseModel;
+export declare const createFileItemResponseModelBaseModel: (item: any) => FileItemResponseModelBaseModel;

package/dist-cms/mocks/data/utils.js

@@ -60,3 +60,8 @@ export const createTextFileItem = (item) => ({
     name: item.name,
     content: item.content,
 });
+export const createFileItemResponseModelBaseModel = (item) => ({
+    path: item.path,
+    name: item.name,
+    icon: item.icon,
+});

package/dist-cms/mocks/handlers/manifests.handlers.js

@@ -4,6 +4,18 @@ export const manifestDevelopmentHandler = rest.get(umbracoPath('/package/manifes
     return res(
     // Respond with a 200 status code
     ctx.status(200), ctx.json([
+        {
+            name: 'My Package Name',
+            version: '1.0.0',
+            extensions: [
+                {
+                    type: 'bundle',
+                    alias: 'My.Package.Bundle',
+                    name: 'My Package Bundle',
+                    js: '/App_Plugins/custom-bundle-package/index.js',
+                },
+            ],
+        },
         {
             name: 'Named Package',
             version: '1.0.0',

package/dist-cms/mocks/handlers/scripts.handlers.d.ts

@@ -0,0 +1,2 @@
+import { RestHandler, MockedRequest, DefaultBodyType } from 'msw';
+export declare const handlers: RestHandler<MockedRequest<DefaultBodyType>>[];

package/dist-cms/mocks/handlers/scripts.handlers.js

@@ -0,0 +1,83 @@
+const { rest } = window.MockServiceWorker;
+import { umbScriptsData } from '../data/scripts.data.js';
+import { umbracoPath } from '../../shared/utils/index.js';
+const treeHandlers = [
+    rest.get(umbracoPath('/tree/script/root'), (req, res, ctx) => {
+        const response = umbScriptsData.getTreeRoot();
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.get(umbracoPath('/tree/script/children'), (req, res, ctx) => {
+        const path = req.url.searchParams.get('path');
+        if (!path)
+            return;
+        const response = umbScriptsData.getTreeItemChildren(path);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.get(umbracoPath('/tree/script/item'), (req, res, ctx) => {
+        const paths = req.url.searchParams.getAll('paths');
+        if (!paths)
+            return;
+        const items = umbScriptsData.getTreeItem(paths);
+        return res(ctx.status(200), ctx.json(items));
+    }),
+];
+const detailHandlers = [
+    rest.get(umbracoPath('/script'), (req, res, ctx) => {
+        const path = decodeURIComponent(req.url.searchParams.get('path') ?? '').replace('-js', '.js');
+        if (!path)
+            return res(ctx.status(400));
+        const response = umbScriptsData.getScript(path);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.get(umbracoPath('/script/item'), (req, res, ctx) => {
+        const path = decodeURIComponent(req.url.searchParams.get('path') ?? '').replace('-js', '.js');
+        if (!path)
+            return res(ctx.status(400, 'no body found'));
+        const response = umbScriptsData.getItem([path]);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.post(umbracoPath('/script'), async (req, res, ctx) => {
+        const requestBody = (await req.json());
+        if (!requestBody)
+            return res(ctx.status(400, 'no body found'));
+        const response = umbScriptsData.insertScript(requestBody);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.delete(umbracoPath('/script'), (req, res, ctx) => {
+        const path = req.url.searchParams.get('path');
+        if (!path)
+            return res(ctx.status(400));
+        const response = umbScriptsData.delete([path]);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.put(umbracoPath('/script'), async (req, res, ctx) => {
+        const requestBody = (await req.json());
+        if (!requestBody)
+            return res(ctx.status(400, 'no body found'));
+        const response = umbScriptsData.updateData(requestBody);
+        return res(ctx.status(200));
+    }),
+];
+const folderHandlers = [
+    rest.get(umbracoPath('script/folder'), (req, res, ctx) => {
+        const path = decodeURIComponent(req.url.searchParams.get('path') ?? '').replace('-js', '.js');
+        if (!path)
+            return res(ctx.status(400));
+        const response = umbScriptsData.getFolder(path);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.post(umbracoPath('script/folder'), (req, res, ctx) => {
+        const requestBody = req.json();
+        if (!requestBody)
+            return res(ctx.status(400, 'no body found'));
+        return res(ctx.status(200));
+    }),
+    rest.delete(umbracoPath('script/folder'), (req, res, ctx) => {
+        const path = decodeURIComponent(req.url.searchParams.get('path') ?? '').replace('-js', '.js');
+        if (!path)
+            return res(ctx.status(400));
+        const response = umbScriptsData.deleteFolder(path);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+];
+export const handlers = [...treeHandlers, ...detailHandlers, ...folderHandlers];