@umbraco-cms/backoffice 14.0.0-178e68bb → 14.0.0-1ab621da

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

@@ -460,7 +460,7 @@ export const data = [
                 publishDate: '2023-02-06T15:32:24.957009',
                 culture: 'en-us',
                 segment: null,
-                name: 'Blog post B',
+                name: 'Simple Document',
                 createDate: '2023-02-06T15:32:05.350038',
                 updateDate: '2023-02-06T15:32:24.957009',
             },
@@ -538,7 +538,29 @@ export const treeData = [
         isEdited: false,
         isTrashed: false,
     },
+    {
+        name: 'Trashed',
+        type: 'document',
+        icon: 'document',
+        hasChildren: false,
+        id: 'trashed-document-id',
+        isContainer: false,
+        parentId: null,
+        noAccess: false,
+        isProtected: false,
+        isPublished: false,
+        isEdited: false,
+        isTrashed: true,
+    },
 ];
+const createDocumentItem = (item) => {
+    return {
+        id: item.id,
+        name: item.variants?.[0].name,
+        contentTypeId: item.contentTypeId,
+    };
+};
+// TODO: look into making a combined document model so we don't need to maintain two+ data sets.
 // 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
@@ -566,14 +588,26 @@ class UmbDocumentData extends UmbEntityData {
         });
         return result;
     }
+    trash(ids) {
+        const result = super.trash(ids);
+        this.treeData = this.treeData.map((x) => {
+            if (x.id && ids.includes(x.id)) {
+                return { ...x, isTrashed: true };
+            }
+            else {
+                return x;
+            }
+        });
+        return result;
+    }
     getTreeRoot() {
-        const items = this.treeData.filter((item) => item.parentId === null);
+        const items = this.treeData.filter((item) => item.parentId === null && item.isTrashed === false);
         const treeItems = items.map((item) => item);
         const total = items.length;
         return { items: treeItems, total };
     }
-    getTreeItemChildren(id) {
-        const items = this.treeData.filter((item) => item.parentId === id);
+    getTreeItemChildrenOf(id) {
+        const items = this.treeData.filter((item) => item.parentId === id && item.isTrashed === false);
         const treeItems = items.map((item) => item);
         const total = items.length;
         return { items: treeItems, total };
@@ -582,6 +616,10 @@ class UmbDocumentData extends UmbEntityData {
         const items = this.treeData.filter((item) => ids.includes(item.id ?? ''));
         return items.map((item) => item);
     }
+    getItems(ids) {
+        const items = this.data.filter((item) => ids.includes(item.id ?? ''));
+        return items.map((item) => createDocumentItem(item));
+    }
     getDocumentByIdAllowedDocumentTypes(id) {
         const item = this.getById(id);
         if (item?.contentTypeId) {
@@ -599,5 +637,17 @@ class UmbDocumentData extends UmbEntityData {
         const total = items?.length;
         return { items, total };
     }
+    getRecycleBinRoot() {
+        const items = this.treeData.filter((item) => item.parentId === null && item.isTrashed === true);
+        const treeItems = items.map((item) => item);
+        const total = items.length;
+        return { items: treeItems, total };
+    }
+    getRecycleBinChildrenOf(parentId) {
+        const items = this.treeData.filter((item) => item.parentId === parentId && item.isTrashed === true);
+        const treeItems = items.map((item) => item);
+        const total = items.length;
+        return { items: treeItems, total };
+    }
 }
 export const umbDocumentData = new UmbDocumentData();

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

@@ -8,6 +8,6 @@ export declare class UmbEntityData<T extends UmbEntityBase> extends UmbData<T> {
     insert(item: T): T;
     save(id: string, saveItem: T): T;
     trash(ids: Array<string>): T[];
-    delete(ids: Array<string>): (string | undefined)[];
+    delete(ids: Array<string>): void;
     updateData(updateItem: T): void;
 }

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

@@ -51,8 +51,6 @@ export class UmbEntityData extends UmbData {
             const item = this.getById(id);
             if (!item)
                 return;
-            // TODO: how do we handle trashed items?
-            // TODO: remove ignore when we know how to handle trashed items.
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             item.isTrashed = true;
@@ -62,19 +60,11 @@ export class UmbEntityData extends UmbData {
         return trashedItems;
     }
     delete(ids) {
-        const deletedKeys = this.data
-            .filter((item) => {
-            if (!item.id)
-                throw new Error('Item has no id');
-            ids.includes(item.id);
-        })
-            .map((item) => item.id);
         this.data = this.data.filter((item) => {
             if (!item.id)
                 throw new Error('Item has no id');
-            ids.indexOf(item.id) === -1;
+            return !ids.includes(item.id);
         });
-        return deletedKeys;
     }
     updateData(updateItem) {
         const itemIndex = this.data.findIndex((item) => item.id === updateItem.id);

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

@@ -1,10 +1,11 @@
 import type { MediaDetails } from '../../packages/media/media/index.js';
 import { UmbEntityData } from './entity.data.js';
-import { ContentTreeItemResponseModel, PagedMediaTreeItemResponseModel } from '../../external/backend-api/index.js';
+import { ContentTreeItemResponseModel, MediaItemResponseModel, PagedMediaTreeItemResponseModel } from '../../external/backend-api/index.js';
 export declare const data: Array<MediaDetails>;
 declare class UmbMediaData extends UmbEntityData<MediaDetails> {
     #private;
     constructor();
+    getItems(ids: Array<string>): Array<MediaItemResponseModel>;
     getTreeRoot(): PagedMediaTreeItemResponseModel;
     getTreeItemChildren(id: string): PagedMediaTreeItemResponseModel;
     getTreeItem(ids: Array<string>): Array<ContentTreeItemResponseModel>;

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

@@ -179,6 +179,13 @@ export const data = [
         variants: [],
     },
 ];
+const createMediaItem = (item) => {
+    return {
+        id: item.id,
+        name: item.name,
+        icon: item.icon,
+    };
+};
 // 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
@@ -188,6 +195,10 @@ class UmbMediaData extends UmbEntityData {
     constructor() {
         super(data);
     }
+    getItems(ids) {
+        const items = this.data.filter((item) => ids.includes(item.id ?? ''));
+        return items.map((item) => createMediaItem(item));
+    }
     getTreeRoot() {
         const items = this.data.filter((item) => item.parentId === null);
         const treeItems = items.map((item) => createContentTreeItem(item));

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();