@umbraco-cms/backoffice 1.0.0-next.de0ffca0 → 1.0.0-next.f2af51c4

package/observable-api.d.ts

@@ -18,55 +18,55 @@ declare class UmbObserverController<T = unknown> extends UmbObserver<T> implemen
 
 /**
  * @export
- * @class BasicState
+ * @class UmbBasicState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class BasicState<T> extends BehaviorSubject<T> {
+declare class UmbBasicState<T> extends BehaviorSubject<T> {
     constructor(initialData: T);
     next(newData: T): void;
 }
 
 /**
  * @export
- * @class BooleanState
+ * @class UmbBooleanState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class BooleanState<T> extends BasicState<T | boolean> {
+declare class UmbBooleanState<T> extends UmbBasicState<T | boolean> {
     constructor(initialData: T | boolean);
 }
 
 /**
  * @export
- * @class NumberState
+ * @class UmbNumberState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class NumberState<T> extends BasicState<T | number> {
+declare class UmbNumberState<T> extends UmbBasicState<T | number> {
     constructor(initialData: T | number);
 }
 
 /**
  * @export
- * @class StringState
- * @extends {BasicState<T>}
+ * @class UmbStringState
+ * @extends {UmbBasicState<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class StringState<T> extends BasicState<T | string> {
+declare class UmbStringState<T> extends UmbBasicState<T | string> {
     constructor(initialData: T | string);
 }
 
-interface ClassStateData {
-    equal(otherClass: ClassStateData): boolean;
+interface UmbClassStateData {
+    equal(otherClass: UmbClassStateData): boolean;
 }
 /**
  * @export
- * @class ClassState
+ * @class UmbClassState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject which can hold class instance which has a equal method to compare in coming instances for changes.
  */
-declare class ClassState<T extends ClassStateData | undefined | null> extends BehaviorSubject<T> {
+declare class UmbClassState<T extends UmbClassStateData | undefined | null> extends BehaviorSubject<T> {
     constructor(initialData: T);
     next(newData: T): void;
 }
@@ -77,12 +77,12 @@ type MemoizationFunction<R> = (previousResult: R, currentResult: R) => boolean;
 
 /**
  * @export
- * @class DeepState
+ * @class UmbDeepState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject which deepFreezes the data to ensure its not manipulated from any implementations.
  * Additionally the Subject ensures the data is unique, not updating any Observes unless there is an actual change of the content.
  */
-declare class DeepState<T> extends BehaviorSubject<T> {
+declare class UmbDeepState<T> extends BehaviorSubject<T> {
     constructor(initialData: T);
     getObservablePart<ReturnType>(mappingFunction: MappingFunction<T, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): rxjs.Observable<ReturnType>;
     next(newData: T): void;
@@ -90,48 +90,62 @@ declare class DeepState<T> extends BehaviorSubject<T> {
 
 /**
  * @export
- * @class ArrayState
- * @extends {DeepState<T>}
+ * @class UmbArrayState
+ * @extends {UmbDeepState<T>}
  * @description - A RxJS BehaviorSubject which deepFreezes the object-data to ensure its not manipulated from any implementations.
  * Additionally the Subject ensures the data is unique, not updating any Observes unless there is an actual change of the content.
  *
  * The ArrayState provides methods to append data when the data is an Object.
  */
-declare class ArrayState<T> extends DeepState<T[]> {
-    private _getUnique?;
+declare class UmbArrayState<T> extends UmbDeepState<T[]> {
+    #private;
     constructor(initialData: T[], getUniqueMethod?: (entry: T) => unknown);
+    /**
+     * @method sortBy
+     * @param {(a: T, b: T) => number} sortMethod - A method to be used for sorting everytime data is set.
+     * @description - A sort method to this Subject.
+     * @example <caption>Example add sort method</caption>
+     * const data = [
+     * 	{ key: 1, value: 'foo'},
+     * 	{ key: 2, value: 'bar'}
+     * ];
+     * const myState = new UmbArrayState(data, (x) => x.key);
+     * myState.sortBy((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
+     */
+    sortBy(sortMethod?: (a: T, b: T) => number): this;
+    next(value: T[]): void;
     /**
      * @method remove
      * @param {unknown[]} uniques - The unique values to remove.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
-     * @example <caption>Example remove entry with key '1' and '2'</caption>
+     * @example <caption>Example remove entry with id '1' and '2'</caption>
      * const data = [
-     * 	{ key: 1, value: 'foo'},
-     * 	{ key: 2, value: 'bar'}
+     * 	{ id: 1, value: 'foo'},
+     * 	{ id: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new UmbArrayState(data, (x) => x.id);
      * myState.remove([1, 2]);
      */
     remove(uniques: unknown[]): this;
     /**
      * @method removeOne
      * @param {unknown} unique - The unique value to remove.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
-     * @example <caption>Example remove entry with key '1'</caption>
+     * @example <caption>Example remove entry with id '1'</caption>
      * const data = [
-     * 	{ key: 1, value: 'foo'},
-     * 	{ key: 2, value: 'bar'}
+     * 	{ id: 1, value: 'foo'},
+     * 	{ id: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new UmbArrayState(data, (x) => x.id);
      * myState.removeOne(1);
      */
     removeOne(unique: unknown): this;
     /**
      * @method filter
      * @param {unknown} filterMethod - The unique value to remove.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
      * @example <caption>Example remove entry with key '1'</caption>
      * const data = [
@@ -139,7 +153,7 @@ declare class ArrayState<T> extends DeepState<T[]> {
      * 	{ key: 2, value: 'bar'},
      * 	{ key: 3, value: 'poo'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new UmbArrayState(data, (x) => x.key);
      * myState.filter((entry) => entry.key !== 1);
      *
      * Result:
@@ -153,28 +167,28 @@ declare class ArrayState<T> extends DeepState<T[]> {
     /**
      * @method appendOne
      * @param {T} entry - new data to be added in this Subject.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Append some new data to this Subject.
      * @example <caption>Example append some data.</caption>
      * const data = [
      * 	{ key: 1, value: 'foo'},
      * 	{ key: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data);
+     * const myState = new UmbArrayState(data);
      * myState.append({ key: 1, value: 'replaced-foo'});
      */
     appendOne(entry: T): this;
     /**
      * @method append
      * @param {T[]} entries - A array of new data to be added in this Subject.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Append some new data to this Subject, if it compares to existing data it will replace it.
      * @example <caption>Example append some data.</caption>
      * const data = [
      * 	{ key: 1, value: 'foo'},
      * 	{ key: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data);
+     * const myState = new UmbArrayState(data);
      * myState.append([
      * 	{ key: 1, value: 'replaced-foo'},
      * 	{ key: 3, value: 'another-bla'}
@@ -185,14 +199,14 @@ declare class ArrayState<T> extends DeepState<T[]> {
      * @method updateOne
      * @param {unknown} unique - Unique value to find entry to update.
      * @param {Partial<T>} entry - new data to be added in this Subject.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Update a item with some new data, requires the ArrayState to be constructed with a getUnique method.
      * @example <caption>Example append some data.</caption>
      * const data = [
      * 	{ key: 1, value: 'foo'},
      * 	{ key: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new UmbArrayState(data, (x) => x.key);
      * myState.updateOne(2, {value: 'updated-bar'});
      */
     updateOne(unique: unknown, entry: Partial<T>): this;
@@ -200,22 +214,22 @@ declare class ArrayState<T> extends DeepState<T[]> {
 
 /**
  * @export
- * @class ObjectState
- * @extends {DeepState<T>}
+ * @class UmbObjectState
+ * @extends {UmbDeepState<T>}
  * @description - A RxJS BehaviorSubject which deepFreezes the object-data to ensure its not manipulated from any implementations.
  * Additionally the Subject ensures the data is unique, not updating any Observes unless there is an actual change of the content.
  *
- * The ObjectState provides methods to append data when the data is an Object.
+ * The UmbObjectState provides methods to append data when the data is an Object.
  */
-declare class ObjectState<T> extends DeepState<T> {
+declare class UmbObjectState<T> extends UmbDeepState<T> {
     /**
      * @method update
      * @param {Partial<T>} partialData - A object containing some of the data to update in this Subject.
      * @description - Append some new data to this Object.
-     * @return {ObjectState<T>} Reference to it self.
+     * @return {UmbObjectState<T>} Reference to it self.
      * @example <caption>Example append some data.</caption>
      * const data = {key: 'myKey', value: 'myInitialValue'};
-     * const myState = new ObjectState(data);
+     * const myState = new UmbObjectState(data);
      * myState.update({value: 'myNewValue'});
      */
     update(partialData: Partial<T>): this;
@@ -240,9 +254,9 @@ declare function createObservablePart<R, T>(source$: Observable<T>, mappingFunct
  * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
  * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
  * @description - Creates a RxJS Observable from RxJS Subject.
- * @example <caption>Example append new entry for a ArrayState or a part of DeepState/ObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
- * const entry = {key: 'myKey', value: 'myValue'};
- * const newDataSet = appendToFrozenArray(mySubject.getValue(), entry, x => x.key === key);
+ * @example <caption>Example append new entry for a ArrayState or a part of UmbDeepState/UmbObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
+ * const entry = {id: 'myKey', value: 'myValue'};
+ * const newDataSet = appendToFrozenArray(mySubject.getValue(), entry, x => x.id === id);
  * mySubject.next(newDataSet);
  */
 declare function appendToFrozenArray<T>(data: T[], entry: T, getUniqueMethod?: (entry: T) => unknown): T[];
@@ -254,11 +268,11 @@ declare function appendToFrozenArray<T>(data: T[], entry: T, getUniqueMethod?: (
  * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
  * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
  * @description - Creates a RxJS Observable from RxJS Subject.
- * @example <caption>Example append new entry for a ArrayState or a part of DeepState/ObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
+ * @example <caption>Example append new entry for a ArrayState or a part of UmbDeepState/UmbObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
  * const partialEntry = {value: 'myValue'};
  * const newDataSet = partialUpdateFrozenArray(mySubject.getValue(), partialEntry, x => x.key === 'myKey');
  * mySubject.next(newDataSet);
  */
 declare function partialUpdateFrozenArray<T>(data: T[], partialEntry: Partial<T>, findMethod: (entry: T) => boolean): T[];
 
-export { ArrayState, BasicState, BooleanState, ClassState, DeepState, MappingFunction, NumberState, ObjectState, StringState, UmbObserver, UmbObserverController, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };
+export { MappingFunction, UmbArrayState, UmbBasicState, UmbBooleanState, UmbClassState, UmbDeepState, UmbNumberState, UmbObjectState, UmbObserver, UmbObserverController, UmbStringState, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@umbraco-cms/backoffice",
-	"version": "1.0.0-next.de0ffca0",
+	"version": "1.0.0-next.f2af51c4",
 	"license": "MIT",
 	"keywords": [
 		"umbraco",

package/picker-input.d.ts

@@ -0,0 +1,24 @@
+import * as rxjs from 'rxjs';
+import { UmbItemRepository } from './repository';
+import { UmbControllerHostElement } from './controller';
+import { UmbModalToken, UmbModalContext } from './modal';
+import { ItemResponseModelBaseModel } from './backend-api';
+
+declare class UmbPickerInputContext<ItemType extends ItemResponseModelBaseModel> {
+    #private;
+    host: UmbControllerHostElement;
+    modalAlias: string | UmbModalToken;
+    repository?: UmbItemRepository<ItemType>;
+    modalContext?: UmbModalContext;
+    selection: rxjs.Observable<string[]>;
+    selectedItems: rxjs.Observable<ItemType[]>;
+    max: number;
+    min: number;
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, modalAlias: string | UmbModalToken, getUniqueMethod?: (entry: ItemType) => string | undefined);
+    getSelection(): string[];
+    setSelection(selection: string[]): void;
+    openPicker(pickerData?: any): void;
+    requestRemoveItem(unique: string): Promise<void>;
+}
+
+export { UmbPickerInputContext };

package/repository.d.ts

@@ -1,4 +1,4 @@
-import { ProblemDetailsModel } from './backend-api';
+import { ProblemDetailsModel, FolderReponseModel, CreateFolderRequestModel, UpdateFolderReponseModel, FolderModelBaseModel, ItemResponseModelBaseModel } from './backend-api';
 import { DataSourceResponse as DataSourceResponse$1 } from './repository';
 import { Observable } from 'rxjs';
 
@@ -7,12 +7,20 @@ interface DataSourceResponse<T = undefined> {
     error?: ProblemDetailsModel;
 }
 
-interface UmbDataSource<T> {
-    createScaffold(parentKey: string | null): Promise<DataSourceResponse$1<T>>;
-    get(key: string): Promise<DataSourceResponse$1<T>>;
-    insert(data: T): Promise<DataSourceResponse$1<T>>;
-    update(data: T): Promise<DataSourceResponse$1<T>>;
-    delete(key: string): Promise<DataSourceResponse$1<T>>;
+interface UmbDataSource<CreateRequestType, UpdateRequestType, ResponseType> {
+    createScaffold(parentId: string | null): Promise<DataSourceResponse$1<CreateRequestType>>;
+    get(unique: string): Promise<DataSourceResponse$1<ResponseType>>;
+    insert(data: CreateRequestType): Promise<any>;
+    update(unique: string, data: UpdateRequestType): Promise<DataSourceResponse$1<ResponseType>>;
+    delete(unique: string): Promise<DataSourceResponse$1>;
+}
+
+interface UmbFolderDataSource {
+    createScaffold(parentId: string | null): Promise<DataSourceResponse<FolderReponseModel>>;
+    get(unique: string): Promise<DataSourceResponse<FolderReponseModel>>;
+    insert(data: CreateFolderRequestModel): Promise<DataSourceResponse<string>>;
+    update(unique: string, data: CreateFolderRequestModel): Promise<DataSourceResponse<UpdateFolderReponseModel>>;
+    delete(unique: string): Promise<DataSourceResponse>;
 }
 
 interface UmbTreeDataSource<PagedItemsType = any, ItemsType = any> {
@@ -21,24 +29,22 @@ interface UmbTreeDataSource<PagedItemsType = any, ItemsType = any> {
     getItems(unique: Array<string>): Promise<DataSourceResponse$1<Array<ItemsType>>>;
 }
 
-interface UmbDetailRepository<DetailType> {
-    createScaffold(parentKey: string | null): Promise<{
-        data?: DetailType;
-        error?: ProblemDetailsModel;
-    }>;
-    requestByKey(key: string): Promise<{
-        data?: DetailType;
-        error?: ProblemDetailsModel;
-    }>;
-    create(data: DetailType): Promise<{
-        error?: ProblemDetailsModel;
-    }>;
-    save(data: DetailType): Promise<{
-        error?: ProblemDetailsModel;
-    }>;
-    delete(key: string): Promise<{
-        error?: ProblemDetailsModel;
-    }>;
+interface UmbItemDataSource<ItemType> {
+    getItems(unique: Array<string>): Promise<DataSourceResponse$1<Array<ItemType>>>;
+}
+
+interface UmbRepositoryErrorResponse {
+    error?: ProblemDetailsModel;
+}
+interface UmbRepositoryResponse<T> extends UmbRepositoryErrorResponse {
+    data?: T;
+}
+interface UmbDetailRepository<CreateRequestType = any, UpdateRequestType = any, ResponseType = any> {
+    createScaffold(parentId: string | null): Promise<UmbRepositoryResponse<CreateRequestType>>;
+    requestById(id: string): Promise<UmbRepositoryResponse<ResponseType>>;
+    create(data: CreateRequestType): Promise<UmbRepositoryErrorResponse>;
+    save(id: string, data: UpdateRequestType): Promise<UmbRepositoryErrorResponse>;
+    delete(id: string): Promise<UmbRepositoryErrorResponse>;
 }
 
 interface UmbPagedData<T> {
@@ -56,14 +62,45 @@ interface UmbTreeRepository<ItemType = any, PagedItemType = UmbPagedData<ItemTyp
         error: ProblemDetailsModel | undefined;
         asObservable?: () => Observable<ItemType[]>;
     }>;
-    requestTreeItems: (uniques: string[]) => Promise<{
+    requestItemsLegacy?: (uniques: string[]) => Promise<{
         data: Array<ItemType> | undefined;
         error: ProblemDetailsModel | undefined;
         asObservable?: () => Observable<ItemType[]>;
     }>;
     rootTreeItems: () => Promise<Observable<ItemType[]>>;
     treeItemsOf: (parentUnique: string | null) => Promise<Observable<ItemType[]>>;
-    treeItems: (uniques: string[]) => Promise<Observable<ItemType[]>>;
+    itemsLegacy?: (uniques: string[]) => Promise<Observable<ItemType[]>>;
+}
+
+interface UmbFolderRepository {
+    createFolderScaffold(parentId: string | null): Promise<{
+        data?: FolderReponseModel;
+        error?: ProblemDetailsModel;
+    }>;
+    createFolder(folderRequest: CreateFolderRequestModel): Promise<{
+        data?: string;
+        error?: ProblemDetailsModel;
+    }>;
+    requestFolder(unique: string): Promise<{
+        data?: FolderReponseModel;
+        error?: ProblemDetailsModel;
+    }>;
+    updateFolder(unique: string, folder: FolderModelBaseModel): Promise<{
+        data?: UpdateFolderReponseModel;
+        error?: ProblemDetailsModel;
+    }>;
+    deleteFolder(id: string): Promise<{
+        error?: ProblemDetailsModel;
+    }>;
+}
+
+interface UmbItemRepository<ItemType extends ItemResponseModelBaseModel> {
+    requestItems: (uniques: string[]) => Promise<{
+        data?: Array<ItemType> | undefined;
+        error?: ProblemDetailsModel | undefined;
+        asObservable?: () => Observable<Array<ItemType>>;
+    }>;
+    items: (uniques: string[]) => Promise<Observable<Array<ItemType>>>;
 }
 
-export { DataSourceResponse, UmbDataSource, UmbDetailRepository, UmbPagedData, UmbTreeDataSource, UmbTreeRepository };
+export { DataSourceResponse, UmbDataSource, UmbDetailRepository, UmbFolderDataSource, UmbFolderRepository, UmbItemDataSource, UmbItemRepository, UmbPagedData, UmbRepositoryErrorResponse, UmbRepositoryResponse, UmbTreeDataSource, UmbTreeRepository };