@umbraco-cms/backoffice 14.0.0-695f1c3f → 14.0.0-709b3cbf

package/dist-cms/external/router-slot/router-slot.d.ts

@@ -0,0 +1,111 @@
+import { IPathFragments, IRoute, IRouteMatch, IRouterSlot, IRoutingInfo, Params, PathFragment } from "./model.js";
+/**
+ * Slot for a node in the router tree.
+ * @slot - Default content.
+ * @event changestate - Dispatched when the router slot state changes.
+ */
+export declare class RouterSlot<D = any, P = any> extends HTMLElement implements IRouterSlot<D, P> {
+    /**
+     * Listeners on the router.
+     */
+    private listeners;
+    /**
+     * The available routes.
+     */
+    private _routes;
+    get routes(): IRoute<D>[];
+    set routes(routes: IRoute<D>[]);
+    /**
+     * The parent router.
+     * Is REQUIRED if this router is a child.
+     * When set, the relevant listeners are added or teared down because they depend on the parent.
+     */
+    _parent: IRouterSlot<P> | null | undefined;
+    get parent(): IRouterSlot<P> | null | undefined;
+    set parent(router: IRouterSlot<P> | null | undefined);
+    private _lockParent;
+    private _setParent;
+    /**
+     * Whether the router is a root router.
+     */
+    get isRoot(): boolean;
+    /**
+     * The current route match.
+     */
+    private _routeMatch;
+    get match(): IRouteMatch<D> | null;
+    /**
+     * The current route of the match.
+     */
+    get route(): IRoute<D> | null;
+    /**
+     * The current path fragment of the match
+     */
+    get fragments(): IPathFragments | null;
+    /**
+     * The current params of the match.
+     */
+    get params(): Params | null;
+    /**
+     * Hooks up the element.
+     */
+    constructor();
+    /**
+     * Query the parent router slot when the router slot is connected.
+     */
+    connectedCallback(): void;
+    /**
+     * Tears down the element.
+     */
+    disconnectedCallback(): void;
+    /**
+     * Queries the parent router.
+     */
+    queryParentRouterSlot(): IRouterSlot<P> | null;
+    /**
+     * Returns an absolute path relative to the router slot.
+     * @param path
+     */
+    constructAbsolutePath(path: PathFragment): string;
+    /**
+     * Adds routes to the router.
+     * Navigates automatically if the router slot is the root and is connected.
+     * @param routes
+     * @param navigate
+     */
+    add(routes: IRoute<D>[], navigate?: boolean): void;
+    /**
+     * Removes all routes.
+     */
+    clear(): void;
+    /**
+     * Each time the path changes, load the new path.
+     */
+    render(): Promise<void>;
+    /**
+     * Attaches listeners, either globally or on the parent router.
+     */
+    protected attachListeners(): void;
+    /**
+     * Clears the children in the DOM.
+     */
+    protected clearChildren(): void;
+    /**
+     * Detaches the listeners.
+     */
+    protected detachListeners(): void;
+    /**
+     * Notify the listeners.
+     */
+    notifyChildRouters<D = any>(info: IRoutingInfo<D>): void;
+    /**
+     * Loads a new path based on the routes.
+     * Returns true if a navigation was made to a new page.
+     */
+    protected renderPath(path: string | PathFragment): Promise<boolean>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "router-slot": RouterSlot;
+    }
+}

package/dist-cms/external/router-slot/util/anchor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook up a click listener to the window that, for all anchor tags
+ * that has a relative HREF, uses the history API instead.
+ */
+export declare function ensureAnchorHistory(): void;

package/dist-cms/external/router-slot/util/events.d.ts

@@ -0,0 +1,26 @@
+import { EventListenerSubscription, GlobalRouterEvent, IRoutingInfo } from "../model";
+/**
+ * Dispatches a did change route event.
+ * @param $elem
+ * @param {IRoute} detail
+ */
+export declare function dispatchRouteChangeEvent<D = any>($elem: HTMLElement, detail: IRoutingInfo<D>): void;
+/**
+ * Dispatches an event on the window object.
+ * @param name
+ * @param detail
+ */
+export declare function dispatchGlobalRouterEvent<D = any>(name: GlobalRouterEvent, detail?: IRoutingInfo<D>): void;
+/**
+ * Adds an event listener (or more) to an element and returns a function to unsubscribe.
+ * @param $elem
+ * @param type
+ * @param listener
+ * @param options
+ */
+export declare function addListener<T extends Event, eventType extends string>($elem: EventTarget, type: eventType[] | eventType, listener: ((e: T) => void), options?: boolean | AddEventListenerOptions): EventListenerSubscription;
+/**
+ * Removes the event listeners in the array.
+ * @param listeners
+ */
+export declare function removeListeners(listeners: EventListenerSubscription[]): void;

package/dist-cms/external/router-slot/util/history.d.ts

@@ -0,0 +1,32 @@
+import { GlobalRouterEvent } from "../model";
+export declare const historyPatches: [string, GlobalRouterEvent[]][];
+/**
+ * Patches the history object by ensuring correct events are dispatches when the history changes.
+ */
+export declare function ensureHistoryEvents(): void;
+/**
+ * Attaches a global router event after the native function on the object has been invoked.
+ * Stores the original function at the _name.
+ * @param obj
+ * @param functionName
+ * @param eventName
+ */
+export declare function attachCallback(obj: any, functionName: string, eventName: GlobalRouterEvent): void;
+/**
+ * Saves the native function on the history object.
+ * @param obj
+ * @param name
+ * @param func
+ */
+export declare function saveNativeFunction(obj: any, name: string, func: (() => void)): void;
+declare global {
+    interface History {
+        "native": {
+            "back": ((distance?: any) => void);
+            "forward": ((distance?: any) => void);
+            "go": ((delta?: any) => void);
+            "pushState": ((data: any, title?: string, url?: string | null) => void);
+            "replaceState": ((data: any, title?: string, url?: string | null) => void);
+        };
+    }
+}

package/dist-cms/external/router-slot/util/index.d.ts

@@ -0,0 +1,6 @@
+export * from './events.js';
+export * from './history.js';
+export * from './router.js';
+export * from './shadow.js';
+export * from './url.js';
+export * from './anchor.js';

package/dist-cms/external/router-slot/util/router.d.ts

@@ -0,0 +1,72 @@
+import { IComponentRoute, IRedirectRoute, IResolverRoute, IRoute, IRouteMatch, IRouterSlot, PageComponent, PathFragment, RouterTree, IRoutingInfo } from "../model";
+/**
+ * Determines whether the path is active.
+ * If the full path starts with the path and is followed by the end of the string or a "/" the path is considered active.
+ * @param path
+ * @param fullPath
+ */
+export declare function isPathActive(path: string | PathFragment, fullPath?: string): boolean;
+/**
+ * Matches a route.
+ * @param route
+ * @param path
+ */
+export declare function matchRoute<D = any>(route: IRoute<D>, path: string | PathFragment): IRouteMatch<D> | null;
+/**
+ * Matches the first route that matches the given path.
+ * @param routes
+ * @param path
+ */
+export declare function matchRoutes<D = any>(routes: IRoute<D>[], path: string | PathFragment): IRouteMatch<D> | null;
+/**
+ * Returns the page from the route.
+ * If the component provided is a function (and not a class) call the function to get the promise.
+ * @param route
+ * @param info
+ */
+export declare function resolvePageComponent(route: IComponentRoute, info: IRoutingInfo): Promise<PageComponent>;
+/**
+ * Determines if a route is a redirect route.
+ * @param route
+ */
+export declare function isRedirectRoute(route: IRoute): route is IRedirectRoute;
+/**
+ * Determines if a route is a resolver route.
+ * @param route
+ */
+export declare function isResolverRoute(route: IRoute): route is IResolverRoute;
+/**
+ * Traverses the router tree up to the root route.
+ * @param slot
+ */
+export declare function traverseRouterTree(slot: IRouterSlot): {
+    tree: RouterTree;
+    depth: number;
+};
+/**
+ * Generates a path based on the router tree.
+ * @param tree
+ * @param depth
+ */
+export declare function getFragments(tree: RouterTree, depth: number): PathFragment[];
+/**
+ * Constructs the correct absolute path based on a router.
+ * - Handles relative paths: "mypath"
+ * - Handles absolute paths: "/mypath"
+ * - Handles traversing paths: "../../mypath"
+ * @param slot
+ * @param path
+ */
+export declare function constructAbsolutePath<D = any, P = any>(slot: IRouterSlot<D, P>, path?: string | PathFragment): string;
+/**
+ * Handles a redirect.
+ * @param slot
+ * @param route
+ */
+export declare function handleRedirect(slot: IRouterSlot, route: IRedirectRoute): void;
+/**
+ * Determines whether the navigation should start based on the current match and the new match.
+ * @param currentMatch
+ * @param newMatch
+ */
+export declare function shouldNavigate<D>(currentMatch: IRouteMatch<D> | null, newMatch: IRouteMatch<D>): boolean;

package/dist-cms/external/router-slot/util/shadow.d.ts

@@ -0,0 +1,15 @@
+import { IRouterSlot } from "../model";
+/**
+ * Queries the parent router.
+ * @param $elem
+ */
+export declare function queryParentRouterSlot<D = any>($elem: Element): IRouterSlot<D> | null;
+/**
+ * Traverses the roots and returns the first match.
+ * The minRoots parameter indicates how many roots should be traversed before we started matching with the query.
+ * @param $elem
+ * @param query
+ * @param minRoots
+ * @param roots
+ */
+export declare function queryParentRoots<T>($elem: Element, query: string, minRoots?: number, roots?: number): T | null;

package/dist-cms/external/router-slot/util/url.d.ts

@@ -0,0 +1,78 @@
+import { ISlashOptions, Query } from "../model";
+/**
+ * The current path of the location.
+ * As default slashes are included at the start and end.
+ * @param options
+ */
+export declare function path(options?: Partial<ISlashOptions>): string;
+/**
+ * Returns the path without the base path.
+ * @param options
+ */
+export declare function pathWithoutBasePath(options?: Partial<ISlashOptions>): string;
+/**
+ * Returns the base path as defined in the <base> tag in the head in a reliable way.
+ * If eg. <base href="/router-slot/"> is defined this function will return "/router-slot/".
+ *
+ * An alternative would be to use regex on document.baseURI,
+ * but that will be unreliable in some cases because it
+ * doesn't use the built in HTMLHyperlinkElementUtils.
+ *
+ * To make this method more performant we could cache the anchor element.
+ * As default it will return the base path with slashes in front and at the end.
+ */
+export declare function basePath(options?: Partial<ISlashOptions>): string;
+/**
+ * Creates an URL using the built in HTMLHyperlinkElementUtils.
+ * An alternative would be to use regex on document.baseURI,
+ * but that will be unreliable in some cases because it
+ * doesn't use the built in HTMLHyperlinkElementUtils.
+ *
+ * As default it will return the base path with slashes in front and at the end.
+ * @param path
+ * @param options
+ */
+export declare function constructPathWithBasePath(path: string, options?: Partial<ISlashOptions>): string;
+/**
+ * Removes the start of the path that matches the part.
+ * @param path
+ * @param part
+ */
+export declare function stripStart(path: string, part: string): string;
+/**
+ * Returns the query string.
+ */
+export declare function queryString(): string;
+/**
+ * Returns the params for the current path.
+ * @returns Params
+ */
+export declare function query(): Query;
+/**
+ * Strips the slash from the start and end of a path.
+ * @param path
+ */
+export declare function stripSlash(path: string): string;
+/**
+ * Ensures the path starts and ends with a slash
+ * @param path
+ */
+export declare function ensureSlash(path: string): string;
+/**
+ * Makes sure that the start and end slashes are present or not depending on the options.
+ * @param path
+ * @param start
+ * @param end
+ */
+export declare function slashify(path: string, { start, end }?: Partial<ISlashOptions>): string;
+/**
+ * Turns a query string into an object.
+ * @param {string} queryString (example: ("test=123&hejsa=LOL&wuhuu"))
+ * @returns {Query}
+ */
+export declare function toQuery(queryString: string): Query;
+/**
+ * Turns a query object into a string query.
+ * @param query
+ */
+export declare function toQueryString(query: Query): string;

package/dist-cms/external/router-slot/util.d.ts

@@ -0,0 +1 @@
+export * from './util/index.js';

package/dist-cms/libs/observable-api/observer.js

@@ -34,7 +34,8 @@ export class UmbObserver {
         });
     }
     hostConnected() {
-        if (this.#subscription.closed) {
+        // Notice: This will not re-subscribe if this controller was destroyed. Only if the subscription was closed.
+        if (this.#subscription?.closed) {
             this.#subscription = this.#source.subscribe(this.#callback);
         }
     }

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

@@ -13,7 +13,7 @@ import { handlers as examineManagementHandlers } from './handlers/examine-manage
 import { handlers as modelsBuilderHandlers } from './handlers/modelsbuilder.handlers.js';
 import { handlers as healthCheckHandlers } from './handlers/health-check.handlers.js';
 import { handlers as profilingHandlers } from './handlers/performance-profiling.handlers.js';
-import { handlers as documentHandlers } from './handlers/document.handlers.js';
+import { handlers as documentHandlers } from './handlers/document/index.js';
 import { handlers as mediaHandlers } from './handlers/media.handlers.js';
 import { handlers as dictionaryHandlers } from './handlers/dictionary.handlers.js';
 import { handlers as mediaTypeHandlers } from './handlers/media-type.handlers.js';
@@ -31,6 +31,7 @@ import { handlers as stylesheetHandlers } from './handlers/stylesheet.handlers.j
 import { handlers as partialViewsHandlers } from './handlers/partial-views.handlers.js';
 import { handlers as tagHandlers } from './handlers/tag-handlers.js';
 import { handlers as configHandlers } from './handlers/config.handlers.js';
+import { handlers as scriptHandlers } from './handlers/scripts.handlers.js';
 const handlers = [
     serverHandlers.serverVersionHandler,
     ...installHandlers,
@@ -64,6 +65,7 @@ const handlers = [
     ...partialViewsHandlers,
     ...tagHandlers,
     ...configHandlers,
+    ...scriptHandlers,
 ];
 switch (import.meta.env.VITE_UMBRACO_INSTALL_STATUS) {
     case 'must-install':

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

@@ -1,5 +1,5 @@
 import { UmbEntityData } from './entity.data.js';
-import { DocumentResponseModel, DocumentTreeItemResponseModel, PagedDocumentTreeItemResponseModel, PagedDocumentTypeResponseModel } from '../../external/backend-api/index.js';
+import { DocumentItemResponseModel, DocumentResponseModel, DocumentTreeItemResponseModel, PagedDocumentTreeItemResponseModel, PagedDocumentTypeResponseModel, PagedRecycleBinItemResponseModel } from '../../external/backend-api/index.js';
 export declare const data: Array<DocumentResponseModel>;
 export declare const treeData: Array<DocumentTreeItemResponseModel>;
 declare class UmbDocumentData extends UmbEntityData<DocumentResponseModel> {
@@ -7,11 +7,15 @@ declare class UmbDocumentData extends UmbEntityData<DocumentResponseModel> {
     constructor();
     insert(item: DocumentResponseModel): DocumentResponseModel;
     update(id: string, item: DocumentResponseModel): DocumentResponseModel;
+    trash(ids: string[]): DocumentResponseModel[];
     getTreeRoot(): PagedDocumentTreeItemResponseModel;
-    getTreeItemChildren(id: string): PagedDocumentTreeItemResponseModel;
+    getTreeItemChildrenOf(id: string): PagedDocumentTreeItemResponseModel;
     getTreeItem(ids: Array<string>): Array<DocumentTreeItemResponseModel>;
+    getItems(ids: Array<string>): Array<DocumentItemResponseModel>;
     getDocumentByIdAllowedDocumentTypes(id: string): PagedDocumentTypeResponseModel;
     getAllowedDocumentTypesAtRoot(): PagedDocumentTypeResponseModel;
+    getRecycleBinRoot(): PagedRecycleBinItemResponseModel;
+    getRecycleBinChildrenOf(parentId: string): PagedRecycleBinItemResponseModel;
 }
 export declare const umbDocumentData: UmbDocumentData;
 export {};

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.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;

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 {};