@umbraco-cms/backoffice 14.0.0-3ffd4766 → 14.0.0-40e04294

package/dist-cms/packages/settings/dashboards/performance-profiling/dashboard-performance-profiling.element.js

@@ -4,78 +4,61 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { UmbTextStyles } from "../../../../shared/style/index.js";
-import { css, html, customElement, state } from '../../../../external/lit/index.js';
+import { UmbTextStyles } from '../../../../shared/style/index.js';
+import { css, html, customElement, state, query, unsafeHTML } from '../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../../shared/lit-element/index.js';
 import { ProfilingResource } from '../../../../external/backend-api/index.js';
 import { tryExecuteAndNotify } from '../../../../shared/resources/index.js';
 export let UmbDashboardPerformanceProfilingElement = class UmbDashboardPerformanceProfilingElement extends UmbLitElement {
     constructor() {
         super(...arguments);
+        this._profilingStatus = true;
         // TODO: Get this from the management api configuration when available
         this._isDebugMode = true;
     }
+    #setToggle(value) {
+        this._toggle.checked = value;
+        this._profilingStatus = value;
+    }
     firstUpdated() {
         this._getProfilingStatus();
     }
     async _getProfilingStatus() {
         const { data } = await tryExecuteAndNotify(this, ProfilingResource.getProfilingStatus());
-        if (data) {
-            this._profilingStatus = data.enabled;
-        }
+        if (!data || !data.enabled)
+            return;
+        this._profilingStatus = data.enabled;
     }
     async _changeProfilingStatus() {
         const { error } = await tryExecuteAndNotify(this, ProfilingResource.putProfilingStatus({ requestBody: { enabled: !this._profilingStatus } }));
-        if (!error) {
-            this._profilingStatus = !this._profilingStatus;
+        if (error) {
+            this.#setToggle(this._profilingStatus);
+        }
+        else {
+            this.#setToggle(!this._profilingStatus);
         }
     }
     renderProfilingStatus() {
         return this._isDebugMode
             ? html `
-					<p>
-						Umbraco is running in debug mode. This means you can use the built-in performance profiler to assess
-						performance when rendering pages.
-					</p>
-					<p>
-						If you want to activate the profiler for a specific page rendering, simply add
-						<strong>umbDebug=true</strong> to the querystring when requesting the page.
-					</p>
-
-					<p>
-						If you want the profiler to be activated by default for all page renderings, you can use the toggle below.
-						It will set a cookie in your browser, which then activates the profiler automatically. In other words, the
-						profiler will only be active by default in your browser - not everyone else's.
-					</p>
+					${unsafeHTML(this.localize.term('profiling_performanceProfilingDescription'))}
 
 					<uui-toggle
+						id="toggle"
 						label="Activate the profiler by default"
 						label-position="left"
-						.checked="${this._profilingStatus}"
+						?checked="${this._profilingStatus}"
 						@change="${this._changeProfilingStatus}"></uui-toggle>
 
-					<h4>Friendly reminder</h4>
-					<p>
-						You should never let a production site run in debug mode. Debug mode is turned off by setting
-						<strong>Umbraco:CMS:Hosting:Debug</strong> to <strong>false</strong> in appsettings.json,
-						appsettings.{Environment}.json or via an environment variable.
-					</p>
+					<h4>${this.localize.term('profiling_reminder')}</h4>
+
+					${unsafeHTML(this.localize.term('profiling_reminderDescription'))}
 			  `
-            : html `
-					<p>
-						Umbraco is not running in debug mode, so you can't use the built-in profiler. This is how it should be for a
-						production site.
-					</p>
-					<p>
-						Debug mode is turned on by setting <strong>Umbraco:CMS:Hosting:Debug</strong> to <strong>true</strong> in
-						appsettings.json, appsettings.{Environment}.json or via an environment variable.
-					</p>
-			  `;
+            : html ` ${unsafeHTML(this.localize.term('profiling_profilerEnabledDescription'))} `;
     }
     render() {
         return html `
-			<uui-box>
-				<h1>Performance Profiling</h1>
+			<uui-box headline=${this.localize.term('profiling_performanceProfiling')}>
 				${typeof this._profilingStatus === 'undefined' ? html `<uui-loader></uui-loader>` : this.renderProfilingStatus()}
 			</uui-box>
 		`;
@@ -108,6 +91,9 @@ __decorate([
 __decorate([
     state()
 ], UmbDashboardPerformanceProfilingElement.prototype, "_isDebugMode", void 0);
+__decorate([
+    query('#toggle')
+], UmbDashboardPerformanceProfilingElement.prototype, "_toggle", void 0);
 UmbDashboardPerformanceProfilingElement = __decorate([
     customElement('umb-dashboard-performance-profiling')
 ], UmbDashboardPerformanceProfilingElement);

package/dist-cms/packages/settings/relation-types/workspace/views/relation/workspace-view-relation-type-relation.element.js

@@ -4,7 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { UmbTextStyles } from "../../../../../../shared/style/index.js";
+import { UmbTextStyles } from '../../../../../../shared/style/index.js';
 import { css, html, customElement, state } from '../../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../../../../shared/lit-element/index.js';
 export let UmbWorkspaceViewRelationTypeRelationElement = class UmbWorkspaceViewRelationTypeRelationElement extends UmbLitElement {
@@ -83,65 +83,65 @@ UmbWorkspaceViewRelationTypeRelationElement = __decorate([
 ], UmbWorkspaceViewRelationTypeRelationElement);
 const MockData = [
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 2,
+        childId: '2',
         childName: 'Child 1',
         createDate: '2021-01-01',
         comment: 'Comment 1',
     },
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 3,
+        childId: '3',
         childName: 'Child 2',
         createDate: '2021-01-01',
         comment: 'Comment 2',
     },
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 4,
+        childId: '4',
         childName: 'Child 3',
         createDate: '2021-01-01',
         comment: 'Comment 3',
     },
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 5,
+        childId: '5',
         childName: 'Child 4',
         createDate: '2021-01-01',
         comment: 'Comment 4',
     },
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 6,
+        childId: '6',
         childName: 'Child 5',
         createDate: '2021-01-01',
         comment: 'Comment 5',
     },
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 7,
+        childId: '7',
         childName: 'Child 6',
         createDate: '2021-01-01',
         comment: 'Comment 6',
     },
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 8,
+        childId: '8',
         childName: 'Child 7',
         createDate: '2021-01-01',
         comment: 'Comment 7',
     },
     {
-        parentId: 1,
+        parentId: '1',
         parentName: 'Parent 1',
-        childId: 9,
+        childId: '9',
         childName: 'Child 8',
         createDate: '2021-01-01',
         comment: 'Comment 8',

package/dist-cms/packages/templating/manifests.js

@@ -2,6 +2,7 @@ import { manifests as menuManifests } from './menu.manifests.js';
 import { manifests as templateManifests } from './templates/manifests.js';
 import { manifests as stylesheetManifests } from './stylesheets/manifests.js';
 import { manifests as partialManifests } from './partial-views/manifests.js';
+import { manifests as scriptsManifest } from './scripts/manifests.js';
 import { manifests as modalManifests } from './modals/manifests.js';
 export const manifests = [
     ...menuManifests,
@@ -9,4 +10,5 @@ export const manifests = [
     ...stylesheetManifests,
     ...partialManifests,
     ...modalManifests,
+    ...scriptsManifest,
 ];

package/dist-cms/packages/templating/scripts/config.d.ts

@@ -0,0 +1,20 @@
+import { ScriptResponseModel } from '../../../external/backend-api/index.js';
+export type ScriptDetails = ScriptResponseModel;
+export declare const SCRIPTS_ENTITY_TYPE = "script";
+export declare const SCRIPTS_ROOT_ENTITY_TYPE = "script-root";
+export declare const SCRIPTS_FOLDER_ENTITY_TYPE = "script-folder";
+export declare const SCRIPTS_FOLDER_EMPTY_ENTITY_TYPE = "script-folder-empty";
+export declare const SCRIPTS_STORE_ALIAS = "Umb.Store.Scripts";
+export declare const UMB_SCRIPTS_STORE_CONTEXT_TOKEN_ALIAS = "Umb.Store.Scripts.Context.Token";
+export declare const SCRIPTS_REPOSITORY_ALIAS = "Umb.Repository.Scripts";
+export declare const SCRIPTS_MENU_ITEM_ALIAS = "Umb.MenuItem.Scripts";
+export declare const SCRIPTS_TREE_ALIAS = "Umb.Tree.Scripts";
+export declare const SCRIPTS_TREE_ITEM_ALIAS = "Umb.TreeItem.Scripts";
+export declare const SCRIPTS_TREE_STORE_ALIAS = "Umb.Store.Scripts.Tree";
+export declare const UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN_ALIAS = "Umb.Store.Scripts.Tree.Context.Token";
+export declare const SCRIPTS_ENTITY_ACTION_DELETE_ALIAS = "Umb.EntityAction.Scripts.Delete";
+export declare const SCRIPTS_ENTITY_ACTION_CREATE_NEW_ALIAS = "Umb.EntityAction.ScriptsFolder.Create.New";
+export declare const SCRIPTS_ENTITY_ACTION_DELETE_FOLDER_ALIAS = "Umb.EntityAction.ScriptsFolder.DeleteFolder";
+export declare const SCRIPTS_ENTITY_ACTION_CREATE_FOLDER_NEW_ALIAS = "Umb.EntityAction.ScriptsFolder.CreateFolder";
+export declare const SCRIPTS_WORKSPACE_ALIAS = "Umb.Workspace.Scripts";
+export declare const SCRIPTS_WORKSPACE_ACTION_SAVE_ALIAS = "Umb.WorkspaceAction.Scripts.Save";

package/dist-cms/packages/templating/scripts/config.js

@@ -0,0 +1,22 @@
+//ENTITY TYPES
+export const SCRIPTS_ENTITY_TYPE = 'script';
+export const SCRIPTS_ROOT_ENTITY_TYPE = 'script-root';
+export const SCRIPTS_FOLDER_ENTITY_TYPE = 'script-folder';
+export const SCRIPTS_FOLDER_EMPTY_ENTITY_TYPE = 'script-folder-empty';
+export const SCRIPTS_STORE_ALIAS = 'Umb.Store.Scripts';
+export const UMB_SCRIPTS_STORE_CONTEXT_TOKEN_ALIAS = 'Umb.Store.Scripts.Context.Token';
+export const SCRIPTS_REPOSITORY_ALIAS = 'Umb.Repository.Scripts';
+export const SCRIPTS_MENU_ITEM_ALIAS = 'Umb.MenuItem.Scripts';
+//TREE
+export const SCRIPTS_TREE_ALIAS = 'Umb.Tree.Scripts';
+export const SCRIPTS_TREE_ITEM_ALIAS = 'Umb.TreeItem.Scripts';
+export const SCRIPTS_TREE_STORE_ALIAS = 'Umb.Store.Scripts.Tree';
+export const UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN_ALIAS = 'Umb.Store.Scripts.Tree.Context.Token';
+//ENTITY (tree) ACTIONS
+export const SCRIPTS_ENTITY_ACTION_DELETE_ALIAS = 'Umb.EntityAction.Scripts.Delete';
+export const SCRIPTS_ENTITY_ACTION_CREATE_NEW_ALIAS = 'Umb.EntityAction.ScriptsFolder.Create.New';
+export const SCRIPTS_ENTITY_ACTION_DELETE_FOLDER_ALIAS = 'Umb.EntityAction.ScriptsFolder.DeleteFolder';
+export const SCRIPTS_ENTITY_ACTION_CREATE_FOLDER_NEW_ALIAS = 'Umb.EntityAction.ScriptsFolder.CreateFolder';
+//WORKSPACE
+export const SCRIPTS_WORKSPACE_ALIAS = 'Umb.Workspace.Scripts';
+export const SCRIPTS_WORKSPACE_ACTION_SAVE_ALIAS = 'Umb.WorkspaceAction.Scripts.Save';

package/dist-cms/packages/templating/scripts/entity-actions/create/create-empty.action.d.ts

@@ -0,0 +1,8 @@
+import { UmbEntityActionBase } from '../../../../core/entity-action/index.js';
+import { UmbControllerHostElement } from '../../../../../libs/controller-api/index.js';
+export declare class UmbCreateScriptAction<T extends {
+    copy(): Promise<void>;
+}> extends UmbEntityActionBase<T> {
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
+    execute(): Promise<void>;
+}

package/dist-cms/packages/templating/scripts/entity-actions/create/create-empty.action.js

@@ -0,0 +1,9 @@
+import { UmbEntityActionBase } from '../../../../core/entity-action/index.js';
+export class UmbCreateScriptAction extends UmbEntityActionBase {
+    constructor(host, repositoryAlias, unique) {
+        super(host, repositoryAlias, unique);
+    }
+    async execute() {
+        history.pushState(null, '', `section/settings/workspace/script/create/${this.unique ?? 'null'}`);
+    }
+}

package/dist-cms/packages/templating/scripts/entity-actions/manifests.d.ts

@@ -0,0 +1,2 @@
+import { ManifestEntityAction } from '../../../core/extension-registry/index.js';
+export declare const manifests: ManifestEntityAction[];

package/dist-cms/packages/templating/scripts/entity-actions/manifests.js

@@ -0,0 +1,56 @@
+import { SCRIPTS_REPOSITORY_ALIAS, SCRIPTS_ENTITY_TYPE, SCRIPTS_FOLDER_ENTITY_TYPE, SCRIPTS_ROOT_ENTITY_TYPE, SCRIPTS_FOLDER_EMPTY_ENTITY_TYPE, SCRIPTS_ENTITY_ACTION_DELETE_ALIAS, SCRIPTS_ENTITY_ACTION_CREATE_NEW_ALIAS, SCRIPTS_ENTITY_ACTION_DELETE_FOLDER_ALIAS, SCRIPTS_ENTITY_ACTION_CREATE_FOLDER_NEW_ALIAS, } from '../config.js';
+import { UmbCreateScriptAction } from './create/create-empty.action.js';
+import { UmbCreateFolderEntityAction, UmbDeleteEntityAction, UmbDeleteFolderEntityAction, } from '../../../core/entity-action/index.js';
+const scriptsViewActions = [
+    {
+        type: 'entityAction',
+        alias: SCRIPTS_ENTITY_ACTION_DELETE_ALIAS,
+        name: 'Delete Scripts Entity Action',
+        meta: {
+            icon: 'umb:trash',
+            label: 'Delete',
+            api: UmbDeleteEntityAction,
+            repositoryAlias: SCRIPTS_REPOSITORY_ALIAS,
+            entityTypes: [SCRIPTS_ENTITY_TYPE],
+        },
+    },
+];
+const scriptsFolderActions = [
+    {
+        type: 'entityAction',
+        alias: SCRIPTS_ENTITY_ACTION_CREATE_NEW_ALIAS,
+        name: 'Create Scripts Entity Under Directory Action',
+        meta: {
+            icon: 'umb:article',
+            label: 'New empty script',
+            api: UmbCreateScriptAction,
+            repositoryAlias: SCRIPTS_REPOSITORY_ALIAS,
+            entityTypes: [SCRIPTS_FOLDER_ENTITY_TYPE, SCRIPTS_FOLDER_EMPTY_ENTITY_TYPE, SCRIPTS_ROOT_ENTITY_TYPE],
+        },
+    },
+    {
+        type: 'entityAction',
+        alias: SCRIPTS_ENTITY_ACTION_DELETE_FOLDER_ALIAS,
+        name: 'Remove empty folder',
+        meta: {
+            icon: 'umb:trash',
+            label: 'Remove folder',
+            api: UmbDeleteFolderEntityAction,
+            repositoryAlias: SCRIPTS_REPOSITORY_ALIAS,
+            entityTypes: [SCRIPTS_FOLDER_EMPTY_ENTITY_TYPE],
+        },
+    },
+    {
+        type: 'entityAction',
+        alias: SCRIPTS_ENTITY_ACTION_CREATE_FOLDER_NEW_ALIAS,
+        name: 'Create empty folder',
+        meta: {
+            icon: 'umb:add',
+            label: 'Create folder',
+            api: UmbCreateFolderEntityAction,
+            repositoryAlias: SCRIPTS_REPOSITORY_ALIAS,
+            entityTypes: [SCRIPTS_FOLDER_EMPTY_ENTITY_TYPE, SCRIPTS_FOLDER_ENTITY_TYPE, SCRIPTS_ROOT_ENTITY_TYPE],
+        },
+    },
+];
+export const manifests = [...scriptsViewActions, ...scriptsFolderActions];

package/dist-cms/packages/templating/scripts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './repository/index.js';
+export * from './config.js';

package/dist-cms/packages/templating/scripts/index.js

@@ -0,0 +1,2 @@
+export * from './repository/index.js';
+export * from './config.js';

package/dist-cms/packages/templating/scripts/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: (import("../../core/index.js").ManifestEntityAction | import("../../core/index.js").ManifestMenuItemTreeKind | import("../../core/index.js").ManifestRepository | import("../../core/index.js").ManifestStore | import("../../core/index.js").ManifestTree | import("../../core/index.js").ManifestTreeItem | import("../../core/index.js").ManifestTreeStore | import("../../core/index.js").ManifestWorkspace | import("../../core/index.js").ManifestWorkspaceAction)[];

package/dist-cms/packages/templating/scripts/manifests.js

@@ -0,0 +1,12 @@
+import { manifests as repositoryManifests } from './repository/manifests.js';
+import { manifests as menuItemManifests } from './menu-item/manifests.js';
+import { manifests as treeManifests } from './tree/manifests.js';
+import { manifests as entityActionsManifests } from './entity-actions/manifests.js';
+import { manifests as workspaceManifests } from './workspace/manifests.js';
+export const manifests = [
+    ...repositoryManifests,
+    ...menuItemManifests,
+    ...treeManifests,
+    ...entityActionsManifests,
+    ...workspaceManifests,
+];

package/dist-cms/packages/templating/scripts/menu-item/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("../../../core/extension-registry/index.js").ManifestMenuItemTreeKind[];

package/dist-cms/packages/templating/scripts/menu-item/manifests.js

@@ -0,0 +1,16 @@
+import { SCRIPTS_ENTITY_TYPE, SCRIPTS_MENU_ITEM_ALIAS, SCRIPTS_TREE_ALIAS } from '../config.js';
+const menuItem = {
+    type: 'menuItem',
+    kind: 'tree',
+    alias: SCRIPTS_MENU_ITEM_ALIAS,
+    name: 'Scripts Menu Item',
+    weight: 10,
+    meta: {
+        label: 'Scripts',
+        icon: 'umb:folder',
+        entityType: SCRIPTS_ENTITY_TYPE,
+        treeAlias: SCRIPTS_TREE_ALIAS,
+        menus: ['Umb.Menu.Templating'],
+    },
+};
+export const manifests = [menuItem];

package/dist-cms/packages/templating/scripts/repository/index.d.ts

@@ -0,0 +1 @@
+export * from './scripts.repository.js';

package/dist-cms/packages/templating/scripts/repository/index.js

@@ -0,0 +1 @@
+export * from './scripts.repository.js';

package/dist-cms/packages/templating/scripts/repository/manifests.d.ts

@@ -0,0 +1,2 @@
+import { ManifestRepository, ManifestStore, ManifestTreeStore } from '../../../core/extension-registry/index.js';
+export declare const manifests: (ManifestRepository | ManifestStore | ManifestTreeStore)[];

package/dist-cms/packages/templating/scripts/repository/manifests.js

@@ -0,0 +1,23 @@
+import { SCRIPTS_REPOSITORY_ALIAS, SCRIPTS_STORE_ALIAS, SCRIPTS_TREE_STORE_ALIAS } from '../config.js';
+import { UmbScriptsRepository } from './scripts.repository.js';
+import { UmbScriptsStore } from './scripts.store.js';
+import { UmbScriptsTreeStore } from './scripts.tree.store.js';
+const repository = {
+    type: 'repository',
+    alias: SCRIPTS_REPOSITORY_ALIAS,
+    name: 'Scripts Repository',
+    class: UmbScriptsRepository,
+};
+const store = {
+    type: 'store',
+    alias: SCRIPTS_STORE_ALIAS,
+    name: 'Scripts Store',
+    class: UmbScriptsStore,
+};
+const treeStore = {
+    type: 'treeStore',
+    alias: SCRIPTS_TREE_STORE_ALIAS,
+    name: 'Scripts Tree Store',
+    class: UmbScriptsTreeStore,
+};
+export const manifests = [repository, store, treeStore];

package/dist-cms/packages/templating/scripts/repository/scripts.repository.d.ts

@@ -0,0 +1,71 @@
+import { ScriptsGetFolderResponse } from './sources/scripts.folder.server.data.js';
+import { DataSourceResponse, UmbDataSourceErrorResponse, UmbDetailRepository, UmbFolderRepository, UmbTreeRepository } from '../../../../shared/repository/index.js';
+import { CreateFolderRequestModel, CreateScriptRequestModel, FileItemResponseModelBaseModel, FileSystemTreeItemPresentationModel, FolderModelBaseModel, FolderResponseModel, ProblemDetails, ScriptResponseModel, TextFileResponseModelBaseModel, UpdateScriptRequestModel } from '../../../../external/backend-api/index.js';
+import { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+import { Observable } from '../../../../external/rxjs/index.js';
+export declare class UmbScriptsRepository implements UmbTreeRepository<FileSystemTreeItemPresentationModel>, UmbDetailRepository<CreateScriptRequestModel, string, UpdateScriptRequestModel, ScriptResponseModel, string>, UmbFolderRepository {
+    #private;
+    constructor(host: UmbControllerHostElement);
+    createFolderScaffold(parentId: string | null): Promise<{
+        data?: FolderResponseModel | undefined;
+        error?: ProblemDetails | undefined;
+    }>;
+    createFolder(requestBody: CreateFolderRequestModel): Promise<{
+        data?: string | undefined;
+        error?: ProblemDetails | undefined;
+    }>;
+    requestFolder(unique: string): Promise<{
+        data?: ScriptsGetFolderResponse | undefined;
+        error?: ProblemDetails | undefined;
+    }>;
+    updateFolder(unique: string, folder: FolderModelBaseModel): Promise<{
+        data?: FolderModelBaseModel | undefined;
+        error?: ProblemDetails | undefined;
+    }>;
+    deleteFolder(path: string): Promise<{
+        error?: ProblemDetails | undefined;
+    }>;
+    requestTreeRoot(): Promise<{
+        data: {
+            id: null;
+            path: null;
+            type: string;
+            name: string;
+            icon: string;
+            hasChildren: boolean;
+        };
+    }>;
+    requestRootTreeItems(): Promise<{
+        data: import("../../../../external/backend-api/index.js").PagedFileSystemTreeItemPresentationModel | undefined;
+        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
+        asObservable: () => Observable<FileSystemTreeItemPresentationModel[]>;
+    }>;
+    requestTreeItemsOf(path: string | null): Promise<{
+        data: any;
+        error: any;
+        asObservable: () => Observable<FileSystemTreeItemPresentationModel[]>;
+    }>;
+    requestTreeItems(keys: Array<string>): Promise<{
+        data: undefined;
+        error: ProblemDetails;
+        asObservable?: undefined;
+    } | {
+        data: any;
+        error: any;
+        asObservable: () => Observable<FileSystemTreeItemPresentationModel[]>;
+    }>;
+    rootTreeItems(): Promise<Observable<FileSystemTreeItemPresentationModel[]>>;
+    treeItemsOf(parentPath: string | null): Promise<Observable<FileSystemTreeItemPresentationModel[]>>;
+    treeItems(paths: Array<string>): Promise<Observable<FileSystemTreeItemPresentationModel[]>>;
+    requestByKey(path: string): Promise<{
+        data: TextFileResponseModelBaseModel | undefined;
+        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
+    }>;
+    requestById(id: string): Promise<DataSourceResponse<any>>;
+    byId(id: string): Promise<Observable<any>>;
+    createScaffold(parentId: string | null, preset: string): Promise<DataSourceResponse<TextFileResponseModelBaseModel>>;
+    create(data: CreateScriptRequestModel): Promise<DataSourceResponse<any>>;
+    save(id: string, requestBody: UpdateScriptRequestModel): Promise<UmbDataSourceErrorResponse>;
+    delete(id: string): Promise<UmbDataSourceErrorResponse>;
+    requestItems(keys: Array<string>): Promise<DataSourceResponse<FileItemResponseModelBaseModel[]>>;
+}

package/dist-cms/packages/templating/scripts/repository/scripts.repository.js

@@ -0,0 +1,154 @@
+import { SCRIPTS_ROOT_ENTITY_TYPE } from '../config.js';
+import { UmbScriptsTreeServerDataSource } from './sources/scripts.tree.server.data.js';
+import { UmbScriptsServerDataSource } from './sources/scripts.detail.server.data.js';
+import { UmbScriptsFolderServerDataSource } from './sources/scripts.folder.server.data.js';
+import { UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN } from './scripts.tree.store.js';
+import { UmbContextConsumerController } from '../../../../libs/context-api/index.js';
+export class UmbScriptsRepository {
+    #init;
+    #host;
+    #treeDataSource;
+    #detailDataSource;
+    #folderDataSource;
+    #treeStore;
+    constructor(host) {
+        this.#host = host;
+        this.#treeDataSource = new UmbScriptsTreeServerDataSource(this.#host);
+        this.#detailDataSource = new UmbScriptsServerDataSource(this.#host);
+        this.#folderDataSource = new UmbScriptsFolderServerDataSource(this.#host);
+        this.#init = Promise.all([
+            new UmbContextConsumerController(this.#host, UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN, (instance) => {
+                this.#treeStore = instance;
+            }),
+        ]);
+    }
+    //#region FOLDER
+    createFolderScaffold(parentId) {
+        const data = {
+            name: '',
+            parentId,
+        };
+        return Promise.resolve({ data, error: undefined });
+    }
+    async createFolder(requestBody) {
+        await this.#init;
+        const req = {
+            parentPath: requestBody.parentId,
+            name: requestBody.name,
+        };
+        const promise = this.#folderDataSource.insert(req);
+        await promise;
+        this.requestTreeItemsOf(requestBody.parentId ? requestBody.parentId : null);
+        return promise;
+    }
+    async requestFolder(unique) {
+        await this.#init;
+        return this.#folderDataSource.get(unique);
+    }
+    updateFolder(unique, folder) {
+        throw new Error('Method not implemented.');
+    }
+    async deleteFolder(path) {
+        await this.#init;
+        const { data } = await this.requestFolder(path);
+        const promise = this.#folderDataSource.delete(path);
+        await promise;
+        this.requestTreeItemsOf(data?.parentPath ? data?.parentPath : null);
+        return promise;
+    }
+    //#endregion
+    //#region TREE
+    async requestTreeRoot() {
+        await this.#init;
+        const data = {
+            id: null,
+            path: null,
+            type: SCRIPTS_ROOT_ENTITY_TYPE,
+            name: 'Scripts',
+            icon: 'umb:folder',
+            hasChildren: true,
+        };
+        return { data };
+    }
+    async requestRootTreeItems() {
+        await this.#init;
+        const { data, error } = await this.#treeDataSource.getRootItems();
+        if (data) {
+            this.#treeStore?.appendItems(data.items);
+        }
+        return { data, error, asObservable: () => this.#treeStore.rootItems };
+    }
+    async requestTreeItemsOf(path) {
+        if (path === null || path === '/' || path === '') {
+            return this.requestRootTreeItems();
+        }
+        await this.#init;
+        const response = await this.#treeDataSource.getChildrenOf({ path, skip: 0, take: 100 });
+        const { data, error } = response;
+        if (data) {
+            this.#treeStore.appendItems(data.items);
+        }
+        return { data, error, asObservable: () => this.#treeStore.childrenOf(path) };
+    }
+    async requestTreeItems(keys) {
+        await this.#init;
+        if (!keys) {
+            const error = { title: 'Keys are missing' };
+            return { data: undefined, error };
+        }
+        const { data, error } = await this.#treeDataSource.getItem(keys);
+        return { data, error, asObservable: () => this.#treeStore.items(keys) };
+    }
+    async rootTreeItems() {
+        await this.#init;
+        return this.#treeStore.rootItems;
+    }
+    async treeItemsOf(parentPath) {
+        if (!parentPath)
+            throw new Error('Parent Path is missing');
+        await this.#init;
+        return this.#treeStore.childrenOf(parentPath);
+    }
+    async treeItems(paths) {
+        if (!paths)
+            throw new Error('Paths are missing');
+        await this.#init;
+        return this.#treeStore.items(paths);
+    }
+    //#endregion
+    //#region DETAILS
+    async requestByKey(path) {
+        if (!path)
+            throw new Error('Path is missing');
+        await this.#init;
+        const { data, error } = await this.#detailDataSource.get(path);
+        return { data, error };
+    }
+    requestById(id) {
+        throw new Error('Method not implemented.');
+    }
+    byId(id) {
+        throw new Error('Method not implemented.');
+    }
+    createScaffold(parentId, preset) {
+        return this.#detailDataSource.createScaffold(parentId, preset);
+    }
+    async create(data) {
+        const promise = this.#detailDataSource.insert(data);
+        await promise;
+        this.requestTreeItemsOf(data.parentPath ? data.parentPath : null);
+        return promise;
+    }
+    save(id, requestBody) {
+        return this.#detailDataSource.update(id, requestBody);
+    }
+    async delete(id) {
+        const promise = this.#detailDataSource.delete(id);
+        const parentPath = id.substring(0, id.lastIndexOf('/'));
+        this.requestTreeItemsOf(parentPath ? parentPath : null);
+        return promise;
+    }
+    requestItems(keys) {
+        return this.#detailDataSource.getItems(keys);
+    }
+}