@umbraco-cms/backoffice 14.0.0-2715ec0f → 14.0.0-2e9e732b

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);
+    }
+}

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

@@ -0,0 +1,31 @@
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbStoreBase } from '../../../core/store/index.js';
+import type { TemplateResponseModel } from '../../../../external/backend-api/index.js';
+import { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+/**
+ * @export
+ * @class UmbScriptsStore
+ * @extends {UmbStoreBase}
+ * @description - Data Store for scripts
+ */
+export declare class UmbScriptsStore extends UmbStoreBase {
+    /**
+     * Creates an instance of UmbScriptsStore.
+     * @param {UmbControllerHostInterface} host
+     * @memberof UmbScriptsStore
+     */
+    constructor(host: UmbControllerHostElement);
+    /**
+     * Append a script to the store
+     * @param {Template} template
+     * @memberof UmbScriptsStore
+     */
+    append(template: TemplateResponseModel): void;
+    /**
+     * Removes scripts in the store with the given uniques
+     * @param {string[]} uniques
+     * @memberof UmbScriptsStore
+     */
+    remove(uniques: string[]): void;
+}
+export declare const UMB_SCRIPTS_STORE_CONTEXT_TOKEN: UmbContextToken<UmbScriptsStore, UmbScriptsStore>;

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

@@ -0,0 +1,37 @@
+import { UMB_SCRIPTS_STORE_CONTEXT_TOKEN_ALIAS } from '../config.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbArrayState } from '../../../../libs/observable-api/index.js';
+import { UmbStoreBase } from '../../../core/store/index.js';
+/**
+ * @export
+ * @class UmbScriptsStore
+ * @extends {UmbStoreBase}
+ * @description - Data Store for scripts
+ */
+export class UmbScriptsStore extends UmbStoreBase {
+    /**
+     * Creates an instance of UmbScriptsStore.
+     * @param {UmbControllerHostInterface} host
+     * @memberof UmbScriptsStore
+     */
+    constructor(host) {
+        super(host, UMB_SCRIPTS_STORE_CONTEXT_TOKEN.toString(), new UmbArrayState([], (x) => x.id));
+    }
+    /**
+     * Append a script to the store
+     * @param {Template} template
+     * @memberof UmbScriptsStore
+     */
+    append(template) {
+        this._data.append([template]);
+    }
+    /**
+     * Removes scripts in the store with the given uniques
+     * @param {string[]} uniques
+     * @memberof UmbScriptsStore
+     */
+    remove(uniques) {
+        this._data.remove(uniques);
+    }
+}
+export const UMB_SCRIPTS_STORE_CONTEXT_TOKEN = new UmbContextToken(UMB_SCRIPTS_STORE_CONTEXT_TOKEN_ALIAS);

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

@@ -0,0 +1,19 @@
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbFileSystemTreeStore } from '../../../core/store/index.js';
+import type { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+export declare const UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN: UmbContextToken<UmbScriptsTreeStore, UmbScriptsTreeStore>;
+/**
+ * Tree Store for scripts
+ *
+ * @export
+ * @class
+ * @extends {UmbEntityTreeStore}
+ */
+export declare class UmbScriptsTreeStore extends UmbFileSystemTreeStore {
+    /**
+     * Creates an instance of UmbScriptsTreeStore.
+     * @param {UmbControllerHostInterface} host
+     * @memberof UmbScriptsTreeStore
+     */
+    constructor(host: UmbControllerHostElement);
+}

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

@@ -0,0 +1,21 @@
+import { UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN_ALIAS } from '../config.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbFileSystemTreeStore } from '../../../core/store/index.js';
+export const UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN = new UmbContextToken(UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN_ALIAS);
+/**
+ * Tree Store for scripts
+ *
+ * @export
+ * @class
+ * @extends {UmbEntityTreeStore}
+ */
+export class UmbScriptsTreeStore extends UmbFileSystemTreeStore {
+    /**
+     * Creates an instance of UmbScriptsTreeStore.
+     * @param {UmbControllerHostInterface} host
+     * @memberof UmbScriptsTreeStore
+     */
+    constructor(host) {
+        super(host, UMB_SCRIPTS_TREE_STORE_CONTEXT_TOKEN.toString());
+    }
+}

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

@@ -0,0 +1,11 @@
+import { FileSystemTreeItemPresentationModel, PagedFileSystemTreeItemPresentationModel } from '../../../../../external/backend-api/index.js';
+import type { DataSourceResponse } from '../../../../../shared/repository/index.js';
+export interface ScriptsTreeDataSource {
+    getRootItems(): Promise<DataSourceResponse<PagedFileSystemTreeItemPresentationModel>>;
+    getChildrenOf({ path, skip, take, }: {
+        path?: string | undefined;
+        skip?: number | undefined;
+        take?: number | undefined;
+    }): Promise<DataSourceResponse<PagedFileSystemTreeItemPresentationModel>>;
+    getItem(ids: Array<string>): Promise<DataSourceResponse<FileSystemTreeItemPresentationModel[]>>;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist-cms/packages/templating/scripts/repository/sources/scripts.detail.server.data.d.ts

@@ -0,0 +1,41 @@
+import { CreateScriptRequestModel, CreateTextFileViewModelBaseModel, ScriptItemResponseModel, ScriptResponseModel, UpdateScriptRequestModel } from '../../../../../external/backend-api/index.js';
+import type { UmbControllerHostElement } from '../../../../../libs/controller-api/index.js';
+import { DataSourceResponse, UmbDataSource } from '../../../../../shared/repository/index.js';
+export declare class UmbScriptsServerDataSource implements UmbDataSource<CreateScriptRequestModel, string, UpdateScriptRequestModel, ScriptResponseModel, string> {
+    #private;
+    constructor(host: UmbControllerHostElement);
+    createScaffold(parentId: string | null, preset?: string | Partial<CreateTextFileViewModelBaseModel> | undefined): Promise<DataSourceResponse<CreateTextFileViewModelBaseModel>>;
+    /**
+     * Fetches a script with the given path from the server
+     * @param {string} path
+     * @return {*}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    get(path: string): Promise<DataSourceResponse<ScriptResponseModel>>;
+    /**
+     * Creates a new script
+     *
+     * @param {CreateScriptRequestModel} requestBody
+     * @return {*}  {Promise<DataSourceResponse<string>>}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    insert(requestBody: CreateScriptRequestModel): Promise<DataSourceResponse<string>>;
+    /**
+     * Updates a script
+     *
+     * @param {string} [unique='']
+     * @param {UpdateScriptRequestModel} requestBody
+     * @return {*}  {Promise<DataSourceResponse<any>>}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    update(unique: string | undefined, requestBody: UpdateScriptRequestModel): Promise<DataSourceResponse<any>>;
+    /**
+     * Deletes a script
+     *
+     * @param {string} path
+     * @return {*}  {Promise<DataSourceResponse>}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    delete(path: string): Promise<DataSourceResponse>;
+    getItems(keys: Array<string>): Promise<DataSourceResponse<ScriptItemResponseModel[]>>;
+}

package/dist-cms/packages/templating/scripts/repository/sources/scripts.detail.server.data.js

@@ -0,0 +1,57 @@
+import { ScriptResource, } from '../../../../../external/backend-api/index.js';
+import { tryExecuteAndNotify } from '../../../../../shared/resources/index.js';
+export class UmbScriptsServerDataSource {
+    #host;
+    constructor(host) {
+        this.#host = host;
+    }
+    createScaffold(parentId, preset) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Fetches a script with the given path from the server
+     * @param {string} path
+     * @return {*}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    get(path) {
+        if (!path)
+            throw new Error('Path is missing');
+        return tryExecuteAndNotify(this.#host, ScriptResource.getScript({ path }));
+    }
+    /**
+     * Creates a new script
+     *
+     * @param {CreateScriptRequestModel} requestBody
+     * @return {*}  {Promise<DataSourceResponse<string>>}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    insert(requestBody) {
+        return tryExecuteAndNotify(this.#host, ScriptResource.postScript({ requestBody }));
+    }
+    //TODO the parameters here are bit ugly, since unique is already in the request body parameter, but it has to be done to marry the UmbDataSource interface an backend API together... maybe come up with some nicer solution
+    /**
+     * Updates a script
+     *
+     * @param {string} [unique='']
+     * @param {UpdateScriptRequestModel} requestBody
+     * @return {*}  {Promise<DataSourceResponse<any>>}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    update(unique = '', requestBody) {
+        return tryExecuteAndNotify(this.#host, ScriptResource.putScript({ requestBody }));
+    }
+    /**
+     * Deletes a script
+     *
+     * @param {string} path
+     * @return {*}  {Promise<DataSourceResponse>}
+     * @memberof UmbScriptsDetailServerDataSource
+     */
+    delete(path) {
+        return tryExecuteAndNotify(this.#host, ScriptResource.deleteScript({ path }));
+    }
+    getItems(keys) {
+        return tryExecuteAndNotify(this.#host, ScriptResource.getScriptItem({ path: keys }));
+    }
+}

package/dist-cms/packages/templating/scripts/repository/sources/scripts.folder.server.data.d.ts

@@ -0,0 +1,17 @@
+import { CreateFolderRequestModel, FolderModelBaseModel, FolderResponseModel } from '../../../../../external/backend-api/index.js';
+import { UmbControllerHostElement } from '../../../../../libs/controller-api/index.js';
+import { DataSourceResponse, UmbFolderDataSource } from '../../../../../shared/repository/index.js';
+export type ScriptsGetFolderResponse = {
+    path: string;
+    parentPath: string;
+    name: string;
+};
+export declare class UmbScriptsFolderServerDataSource implements UmbFolderDataSource {
+    #private;
+    constructor(host: UmbControllerHostElement);
+    createScaffold(parentId: string | null): Promise<DataSourceResponse<FolderResponseModel>>;
+    get(unique: string): Promise<DataSourceResponse<ScriptsGetFolderResponse>>;
+    insert(requestBody: CreateFolderRequestModel): Promise<DataSourceResponse<string>>;
+    update(unique: string, data: CreateFolderRequestModel): Promise<DataSourceResponse<FolderModelBaseModel>>;
+    delete(path: string): Promise<DataSourceResponse<unknown>>;
+}

package/dist-cms/packages/templating/scripts/repository/sources/scripts.folder.server.data.js

@@ -0,0 +1,23 @@
+import { ScriptResource, } from '../../../../../external/backend-api/index.js';
+import { tryExecuteAndNotify } from '../../../../../shared/resources/index.js';
+export class UmbScriptsFolderServerDataSource {
+    #host;
+    constructor(host) {
+        this.#host = host;
+    }
+    createScaffold(parentId) {
+        throw new Error('Method not implemented.');
+    }
+    get(unique) {
+        return tryExecuteAndNotify(this.#host, ScriptResource.getScriptFolder({ path: unique }));
+    }
+    insert(requestBody) {
+        return tryExecuteAndNotify(this.#host, ScriptResource.postScriptFolder({ requestBody }));
+    }
+    update(unique, data) {
+        throw new Error('Method not implemented.');
+    }
+    delete(path) {
+        return tryExecuteAndNotify(this.#host, ScriptResource.deleteScriptFolder({ path }));
+    }
+}

package/dist-cms/packages/templating/scripts/repository/sources/scripts.tree.server.data.d.ts

@@ -0,0 +1,14 @@
+import { ScriptsTreeDataSource } from './index.js';
+import { ProblemDetails } from '../../../../../external/backend-api/index.js';
+import { UmbControllerHostElement } from '../../../../../libs/controller-api/index.js';
+export declare class UmbScriptsTreeServerDataSource implements ScriptsTreeDataSource {
+    #private;
+    constructor(host: UmbControllerHostElement);
+    getRootItems(): Promise<import("../../../../../shared/repository/index.js").DataSourceResponse<import("../../../../../external/backend-api/index.js").PagedFileSystemTreeItemPresentationModel>>;
+    getChildrenOf({ path, skip, take, }: {
+        path?: string | undefined;
+        skip?: number | undefined;
+        take?: number | undefined;
+    }): Promise<ProblemDetails | import("../../../../../shared/repository/index.js").DataSourceResponse<import("../../../../../external/backend-api/index.js").PagedFileSystemTreeItemPresentationModel>>;
+    getItem(path: Array<string>): Promise<ProblemDetails | import("../../../../../shared/repository/index.js").DataSourceResponse<import("../../../../../external/backend-api/index.js").FileItemResponseModelBaseModel[]>>;
+}

package/dist-cms/packages/templating/scripts/repository/sources/scripts.tree.server.data.js

@@ -0,0 +1,31 @@
+import { ScriptResource } from '../../../../../external/backend-api/index.js';
+import { tryExecuteAndNotify } from '../../../../../shared/resources/index.js';
+export class UmbScriptsTreeServerDataSource {
+    #host;
+    constructor(host) {
+        this.#host = host;
+    }
+    async getRootItems() {
+        return tryExecuteAndNotify(this.#host, ScriptResource.getTreeScriptRoot({}));
+    }
+    async getChildrenOf({ path, skip, take, }) {
+        if (!path) {
+            const error = { title: 'Path is missing' };
+            return error;
+        }
+        return tryExecuteAndNotify(this.#host, ScriptResource.getTreeScriptChildren({
+            path,
+            skip,
+            take,
+        }));
+    }
+    async getItem(path) {
+        if (!path) {
+            const error = { title: 'Paths are missing' };
+            return error;
+        }
+        return tryExecuteAndNotify(this.#host, ScriptResource.getScriptItem({
+            path,
+        }));
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+import { SCRIPTS_ENTITY_TYPE, SCRIPTS_REPOSITORY_ALIAS, SCRIPTS_ROOT_ENTITY_TYPE, SCRIPTS_TREE_ALIAS, SCRIPTS_TREE_ITEM_ALIAS, } from '../config.js';
+const tree = {
+    type: 'tree',
+    alias: SCRIPTS_TREE_ALIAS,
+    name: 'Scripts Tree',
+    weight: 30,
+    meta: {
+        repositoryAlias: SCRIPTS_REPOSITORY_ALIAS,
+    },
+};
+const treeItem = {
+    type: 'treeItem',
+    kind: 'fileSystem',
+    alias: SCRIPTS_TREE_ITEM_ALIAS,
+    name: 'Scripts Tree Item',
+    meta: {
+        entityTypes: [SCRIPTS_ROOT_ENTITY_TYPE, SCRIPTS_ENTITY_TYPE],
+    },
+};
+export const manifests = [tree, treeItem];

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

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

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

@@ -0,0 +1,32 @@
+import { SCRIPTS_ENTITY_TYPE, SCRIPTS_WORKSPACE_ALIAS } from '../config.js';
+import { UmbSaveWorkspaceAction } from '../../../core/workspace/index.js';
+const workspace = {
+    type: 'workspace',
+    alias: SCRIPTS_WORKSPACE_ALIAS,
+    name: 'Scripts Workspace',
+    loader: () => import('./scripts-workspace.element.js'),
+    meta: {
+        entityType: SCRIPTS_ENTITY_TYPE,
+    },
+};
+//TODO: this does not work for some reason
+const workspaceActions = [
+    {
+        type: 'workspaceAction',
+        alias: 'Umb.WorkspaceAction.Scripts.Save',
+        name: 'Save Script Workspace Action',
+        meta: {
+            label: 'Save',
+            look: 'primary',
+            color: 'positive',
+            api: UmbSaveWorkspaceAction,
+        },
+        conditions: [
+            {
+                alias: 'Umb.Condition.WorkspaceAlias',
+                match: workspace.alias,
+            },
+        ],
+    },
+];
+export const manifests = [workspace, ...workspaceActions];

package/dist-cms/packages/templating/scripts/workspace/scripts-workspace-edit.element.d.ts

@@ -0,0 +1,24 @@
+import { PropertyValueMap } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../../shared/lit-element/index.js';
+export declare class UmbScriptsWorkspaceEditElement extends UmbLitElement {
+    #private;
+    private get _name();
+    private set _name(value);
+    private _content?;
+    private _path?;
+    private _dirName?;
+    private _ready?;
+    private _codeEditor?;
+    private _modalContext?;
+    private inputQuery$;
+    constructor();
+    protected willUpdate(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("@lit/reactive-element/css-tag.js").CSSResult[];
+}
+export default UmbScriptsWorkspaceEditElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-scripts-workspace-edit': UmbScriptsWorkspaceEditElement;
+    }
+}