@umbraco-cms/backoffice 16.3.2 → 16.3.4

package/dist-cms/libs/observable-api/states/array-state.d.ts

@@ -157,6 +157,26 @@ export declare class UmbArrayState<T, U = unknown> extends UmbDeepState<T[]> {
      * ]);
      */
     append(entries: T[]): this;
+    /**
+     * @function replace
+     * @param {Partial<T>} entires - data of entries to be replaced.
+     * @returns {UmbArrayState<T>} Reference to it self.
+     * @description - Replaces one or more entries, 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 UmbArrayState(data, (x) => x.key);
+     * const updates = [
+     * 	{ key: 1, value: 'foo2'},
+     * 	{ key: 3, value: 'bar2'}
+     * ];
+     * myState.replace(updates);
+     * // Only the existing item gets replaced:
+     * myState.getValue(); // -> [{ key: 1, value: 'foo2'}, { key: 2, value: 'bar'}]
+     */
+    replace(entries: Array<T>): UmbArrayState<T>;
     /**
      * @function updateOne
      * @param {U} unique - Unique value to find entry to update.

package/dist-cms/libs/observable-api/states/array-state.js

@@ -1,6 +1,7 @@
 import { partialUpdateFrozenArray } from '../utils/partial-update-frozen-array.function.js';
 import { pushAtToUniqueArray } from '../utils/push-at-to-unique-array.function.js';
 import { pushToUniqueArray } from '../utils/push-to-unique-array.function.js';
+import { replaceInUniqueArray } from '../utils/replace-in-unique-array.function.js';
 import { UmbDeepState } from './deep-state.js';
 /**
  * @class UmbArrayState
@@ -254,6 +255,38 @@ export class UmbArrayState extends UmbDeepState {
         }
         return this;
     }
+    /**
+     * @function replace
+     * @param {Partial<T>} entires - data of entries to be replaced.
+     * @returns {UmbArrayState<T>} Reference to it self.
+     * @description - Replaces one or more entries, 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 UmbArrayState(data, (x) => x.key);
+     * const updates = [
+     * 	{ key: 1, value: 'foo2'},
+     * 	{ key: 3, value: 'bar2'}
+     * ];
+     * myState.replace(updates);
+     * // Only the existing item gets replaced:
+     * myState.getValue(); // -> [{ key: 1, value: 'foo2'}, { key: 2, value: 'bar'}]
+     */
+    replace(entries) {
+        if (this.getUniqueMethod) {
+            const next = [...this.getValue()];
+            entries.forEach((entry) => {
+                replaceInUniqueArray(next, entry, this.getUniqueMethod);
+            });
+            this.setValue(next);
+        }
+        else {
+            throw new Error("Can't replace entries of an ArrayState without a getUnique method provided when constructed.");
+        }
+        return this;
+    }
     /**
      * @function updateOne
      * @param {U} unique - Unique value to find entry to update.

package/dist-cms/libs/observable-api/utils/index.d.ts

@@ -12,5 +12,6 @@ export * from './observe-multiple.function.js';
 export * from './partial-update-frozen-array.function.js';
 export * from './push-at-to-unique-array.function.js';
 export * from './push-to-unique-array.function.js';
+export * from './replace-in-unique-array.function.js';
 export * from './simple-hash-code.function.js';
 export * from './strict-equality-memoization.function.js';

package/dist-cms/libs/observable-api/utils/index.js

@@ -12,5 +12,6 @@ export * from './observe-multiple.function.js';
 export * from './partial-update-frozen-array.function.js';
 export * from './push-at-to-unique-array.function.js';
 export * from './push-to-unique-array.function.js';
+export * from './replace-in-unique-array.function.js';
 export * from './simple-hash-code.function.js';
 export * from './strict-equality-memoization.function.js';

package/dist-cms/libs/observable-api/utils/replace-in-unique-array.function.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @function replaceInUniqueArray
+ * @param {T[]} data - An array of objects.
+ * @param {T} entry - The object to replace with.
+ * @param {getUniqueMethod: (entry: T) => unknown} [getUniqueMethod] - Method to get the unique value of an entry.
+ * @description - Replaces an item of an Array.
+ * @example <caption>Example replace an entry of an Array. Where the key is unique and the item will only be replaced if matched with existing.</caption>
+ * const data = [{key: 'myKey', value:'initialValue'}];
+ * const entry = {key: 'myKey', value: 'replacedValue'};
+ * const newDataSet = replaceInUniqueArray(data, entry, x => x.key === key);
+ */
+export declare function replaceInUniqueArray<T>(data: T[], entry: T, getUniqueMethod: (entry: T) => unknown): T[];

package/dist-cms/libs/observable-api/utils/replace-in-unique-array.function.js

@@ -0,0 +1,19 @@
+/**
+ * @function replaceInUniqueArray
+ * @param {T[]} data - An array of objects.
+ * @param {T} entry - The object to replace with.
+ * @param {getUniqueMethod: (entry: T) => unknown} [getUniqueMethod] - Method to get the unique value of an entry.
+ * @description - Replaces an item of an Array.
+ * @example <caption>Example replace an entry of an Array. Where the key is unique and the item will only be replaced if matched with existing.</caption>
+ * const data = [{key: 'myKey', value:'initialValue'}];
+ * const entry = {key: 'myKey', value: 'replacedValue'};
+ * const newDataSet = replaceInUniqueArray(data, entry, x => x.key === key);
+ */
+export function replaceInUniqueArray(data, entry, getUniqueMethod) {
+    const unique = getUniqueMethod(entry);
+    const indexToReplace = data.findIndex((x) => getUniqueMethod(x) === unique);
+    if (indexToReplace !== -1) {
+        data[indexToReplace] = entry;
+    }
+    return data;
+}

package/dist-cms/packages/core/picker-input/picker-input.context.js

@@ -92,7 +92,6 @@ export class UmbPickerInputContext extends UmbContextBase {
     #removeItem(unique) {
         const newSelection = this.getSelection().filter((value) => value !== unique);
         this.setSelection(newSelection);
-        this.#itemManager.removeStatus(unique);
         this.getHostElement().dispatchEvent(new UmbChangeEvent());
     }
 }

package/dist-cms/packages/core/repository/repository-items.manager.d.ts

@@ -23,6 +23,10 @@ export declare class UmbRepositoryItemsManager<ItemType extends {
     setUniques(uniques: string[] | undefined): void;
     getItems(): Array<ItemType>;
     itemByUnique(unique: string): import("rxjs").Observable<ItemType | undefined>;
+    /**
+     * @deprecated - This is resolved by setUniques, no need to update statuses.
+     * @param unique {string} - The unique identifier of the item to remove the status of.
+     */
     removeStatus(unique: string): void;
     getItemByUnique(unique: string): Promise<Exclude<ItemType, undefined>>;
     destroy(): void;

package/dist-cms/packages/core/repository/repository-items.manager.js

@@ -61,14 +61,17 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
         this.observe(this.uniques, (uniques) => {
             if (uniques.length === 0) {
                 this.#items.setValue([]);
+                this.#statuses.setValue([]);
                 return;
             }
             // TODO: This could be optimized so we only load the appended items, but this requires that the response checks that an item is still present in uniques. [NL]
-            // Check if we already have the items, and then just sort them:
-            const items = this.#items.getValue();
-            if (uniques.length === items.length &&
-                uniques.every((unique) => items.find((item) => this.#getUnique(item) === unique))) {
+            // Check if we already have the statuses, and then just sort them:
+            const statuses = this.#statuses.getValue();
+            if (uniques.length === statuses.length &&
+                uniques.every((unique) => statuses.find((status) => status.unique === unique))) {
+                const items = this.#items.getValue();
                 this.#items.setValue(this.#sortByUniques(items));
+                this.#statuses.setValue(this.#sortStatusByUniques(statuses));
             }
             else {
                 // We need to load new items, so ...
@@ -93,9 +96,17 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
     itemByUnique(unique) {
         return this.#items.asObservablePart((items) => items.find((item) => this.#getUnique(item) === unique));
     }
+    /**
+     * @deprecated - This is resolved by setUniques, no need to update statuses.
+     * @param unique {string} - The unique identifier of the item to remove the status of.
+     */
     removeStatus(unique) {
-        const newStatuses = this.#statuses.getValue().filter((status) => status.unique !== unique);
-        this.#statuses.setValue(newStatuses);
+        new UmbDeprecation({
+            removeInVersion: '18.0.0',
+            deprecated: 'removeStatus',
+            solution: 'Statuses are removed automatically when setting uniques',
+        }).warn();
+        this.#statuses.filter((status) => status.unique !== unique);
     }
     async getItemByUnique(unique) {
         // TODO: Make an observeOnce feature, to avoid this amount of code: [NL]
@@ -109,7 +120,9 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
         if (!this.repository)
             throw new Error('Repository is not initialized');
         const requestedUniques = this.getUniques();
-        this.#statuses.setValue(requestedUniques.map((unique) => ({
+        this.#statuses.setValue(
+        // No need to do sorting here as we just got the unique in the right order above.
+        requestedUniques.map((unique) => ({
             state: {
                 type: 'loading',
             },
@@ -125,7 +138,7 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
             return;
         }
         if (error) {
-            this.#statuses.append(requestedUniques.map((unique) => ({
+            this.#statuses.replace(requestedUniques.map((unique) => ({
                 state: {
                     type: 'error',
                     error: '#general_error',
@@ -140,7 +153,7 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
             const rejectedUniques = requestedUniques.filter((unique) => !data.find((item) => this.#getUnique(item) === unique));
             const resolvedUniques = requestedUniques.filter((unique) => !rejectedUniques.includes(unique));
             this.#items.remove(rejectedUniques);
-            this.#statuses.append([
+            this.#statuses.replace([
                 ...rejectedUniques.map((unique) => ({
                     state: {
                         type: 'error',
@@ -168,12 +181,11 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
             throw new Error('Repository is not initialized');
         const { data, error } = await this.repository.requestItems([unique]);
         if (error) {
-            this.#statuses.appendOne({
+            this.#statuses.updateOne(unique, {
                 state: {
                     type: 'error',
                     error: '#general_notFound',
                 },
-                unique,
             });
         }
         if (data) {
@@ -184,6 +196,7 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
                 const newItems = [...items];
                 newItems[index] = data[0];
                 this.#items.setValue(this.#sortByUniques(newItems));
+                // No need to update statuses here, as the item is the same, just updated.
             }
         }
     }
@@ -197,6 +210,17 @@ export class UmbRepositoryItemsManager extends UmbControllerBase {
             return aIndex - bIndex;
         });
     }
+    /** Just needed for the deprecation implementation to work, do not bring this into 17.0 [NL] */
+    #sortStatusByUniques(data) {
+        if (!data)
+            return [];
+        const uniques = this.getUniques();
+        return [...data].sort((a, b) => {
+            const aIndex = uniques.indexOf(a.unique ?? '');
+            const bIndex = uniques.indexOf(b.unique ?? '');
+            return aIndex - bIndex;
+        });
+    }
     #onEntityUpdatedEvent;
     destroy() {
         this.#eventContext?.removeEventListener(UmbEntityUpdatedEvent.TYPE, this.#onEntityUpdatedEvent);