@agorapulse/ui-components 18.0.8 → 18.0.10

package/esm2022/nav-selector/utils/nav-selector.folding.mjs

@@ -0,0 +1,219 @@
+import { isInternalNavSelectorEntryACategory, isInternalNavSelectorEntryAGroup, isInternalNavSelectorEntryALeaf, } from '../nav-selector';
+import { isInternalNavSelectorEntryALeafFocusable } from '../utils/leaf.utils';
+/**
+ * Class to handle the folding and unfolding of nav selector entries.
+ */
+export class NavSelectorFolding {
+    /**
+     * Toggle the folding state of an entry.
+     *
+     * @see {@link NavSelectorFolding.fold} and {@link NavSelectorFolding.unfold} for more information on folding and unfolding.
+     *
+     * @param entries nav selector entries
+     * @param entryUid the entry uid to toggle
+     * @param minified true if the nav selector is minified. Needed for leaf as they are not foldable in minified mode
+     */
+    static toggleFolding(entries, entryUid, minified) {
+        return this.toggleEntryFolding(entries, entryUid, minified);
+    }
+    /**
+     * Fold an entry.
+     *
+     * Set unfocusable on all children of the folded entry.
+     * Compute whenever the counter and token invalid should be displayed on groups and leaves.
+     *
+     * @param entries nav selector entries
+     * @param entryUid the entry uid to fold
+     * @param minified true if the nav selector is minified. Needed for leaf as they are not foldable in minified mode
+     */
+    static fold(entries, entryUid, minified) {
+        return this.foldEntry(entries, entryUid, minified);
+    }
+    /**
+     * Unfold an entry.
+     *
+     * Set focusable on all children of the folded entry.
+     * Compute whenever the counter and token invalid should be displayed on groups and leaves.
+     *
+     * @param entries nav selector entries
+     * @param entryUid the entry uid to unfold
+     * @param minified true if the nav selector is minified. Needed for leaf as they are not foldable in minified mode
+     */
+    static unfold(entries, entryUid, minified) {
+        return this.unfoldEntry(entries, entryUid, minified);
+    }
+    static toggleEntryFolding(entries, entryUid, minified, parentFolded = false) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryACategory(entry)) {
+                if (entry.uid === entryUid) {
+                    const folded = !entry.folded;
+                    if (folded) {
+                        return this.foldCategory(entry, minified);
+                    }
+                    else {
+                        return this.unfoldCategory(entry, minified);
+                    }
+                }
+                return {
+                    ...entry,
+                    children: this.toggleEntryFolding(entry.children, entryUid, minified, entry.folded),
+                };
+            }
+            if (isInternalNavSelectorEntryAGroup(entry)) {
+                if (entry.uid === entryUid) {
+                    const folded = !entry.folded;
+                    if (folded) {
+                        return this.foldGroup(entry, minified);
+                    }
+                    else {
+                        return this.unfoldGroup(entry, minified);
+                    }
+                }
+                return {
+                    ...entry,
+                    children: this.toggleEntryFolding(entry.children, entryUid, minified, parentFolded || entry.folded),
+                };
+            }
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                if (entry.uid === entryUid) {
+                    const folded = !entry.folded;
+                    if (folded) {
+                        return this.foldLeaf(entry, minified);
+                    }
+                    else {
+                        return this.unfoldLeaf(entry, minified);
+                    }
+                }
+                return {
+                    ...entry,
+                    focusable: isInternalNavSelectorEntryALeafFocusable(entry, { minified, parentFolded }),
+                };
+            }
+            return { ...entry, focusable: !parentFolded };
+        });
+    }
+    static foldEntry(entries, entryUid, minified, parentFolded = false) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryACategory(entry)) {
+                if (entry.uid === entryUid) {
+                    return this.foldCategory(entry, minified);
+                }
+                return {
+                    ...entry,
+                    children: this.foldEntry(entry.children, entryUid, minified, entry.folded),
+                };
+            }
+            if (isInternalNavSelectorEntryAGroup(entry)) {
+                if (entry.uid === entryUid) {
+                    return this.foldGroup(entry, minified);
+                }
+                return {
+                    ...entry,
+                    focusable: !parentFolded,
+                    children: this.foldEntry(entry.children, entryUid, minified, parentFolded || entry.folded),
+                };
+            }
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                if (entry.uid === entryUid) {
+                    return this.foldLeaf(entry, minified);
+                }
+                return {
+                    ...entry,
+                    focusable: isInternalNavSelectorEntryALeafFocusable(entry, { minified, parentFolded }),
+                };
+            }
+            return { ...entry, focusable: !parentFolded };
+        });
+    }
+    static unfoldEntry(entries, entryUid, minified, parentFolded = false) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryACategory(entry)) {
+                if (entry.uid === entryUid) {
+                    return this.unfoldCategory(entry, minified);
+                }
+                return {
+                    ...entry,
+                    children: this.unfoldEntry(entry.children, entryUid, minified, entry.folded),
+                };
+            }
+            if (isInternalNavSelectorEntryAGroup(entry)) {
+                if (entry.uid === entryUid) {
+                    return this.unfoldGroup(entry, minified);
+                }
+                return {
+                    ...entry,
+                    children: this.unfoldEntry(entry.children, entryUid, minified, parentFolded || entry.folded),
+                    focusable: !parentFolded,
+                };
+            }
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                if (entry.uid === entryUid) {
+                    return this.unfoldLeaf(entry, minified);
+                }
+                return {
+                    ...entry,
+                    focusable: isInternalNavSelectorEntryALeafFocusable(entry, { minified, parentFolded }),
+                };
+            }
+            return { ...entry, focusable: !parentFolded };
+        });
+    }
+    static foldCategory(category, minified) {
+        return {
+            ...category,
+            folded: true,
+            children: this.foldEntry(category.children, category.uid, minified, true),
+        };
+    }
+    static unfoldCategory(category, minified) {
+        return {
+            ...category,
+            folded: false,
+            children: this.unfoldEntry(category.children, category.uid, minified, false),
+        };
+    }
+    static foldGroup(group, minified) {
+        return {
+            ...group,
+            folded: true,
+            children: this.foldEntry(group.children, group.uid, minified, true),
+            displayCounter: !!group.counter,
+            displayTokenInvalid: group.children.some(({ displayTokenInvalid }) => displayTokenInvalid),
+        };
+    }
+    static unfoldGroup(group, minified) {
+        return {
+            ...group,
+            folded: false,
+            children: this.unfoldEntry(group.children, group.uid, minified, false),
+            displayCounter: false,
+            displayTokenInvalid: false,
+        };
+    }
+    static foldLeaf(leaf, minified) {
+        if (!leaf.foldable || minified) {
+            return leaf;
+        }
+        return {
+            ...leaf,
+            displayCounter: true,
+            folded: true,
+            details: leaf.details.map(detail => ({ ...detail, focusable: false })),
+        };
+    }
+    static unfoldLeaf(leaf, minified) {
+        if (!leaf.foldable || minified) {
+            return leaf;
+        }
+        return {
+            ...leaf,
+            displayCounter: false,
+            folded: false,
+            details: leaf.details.map((detail, idx) => ({
+                ...detail,
+                focusable: idx < leaf.viewMoreDetailsDisplayedLimit,
+            })),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-selector.folding.js","sourceRoot":"","sources":["../../../../../libs/ui-components/nav-selector/src/utils/nav-selector.folding.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    InternalNavSelectorCategory,\n    InternalNavSelectorEntry,\n    InternalNavSelectorGroup,\n    InternalNavSelectorLeaf,\n    isInternalNavSelectorEntryACategory,\n    isInternalNavSelectorEntryAGroup,\n    isInternalNavSelectorEntryALeaf,\n} from '../nav-selector';\nimport { isInternalNavSelectorEntryALeafFocusable } from '../utils/leaf.utils';\n\n/**\n * Class to handle the folding and unfolding of nav selector entries.\n */\nexport class NavSelectorFolding {\n    /**\n     * Toggle the folding state of an entry.\n     *\n     * @see {@link NavSelectorFolding.fold} and {@link NavSelectorFolding.unfold} for more information on folding and unfolding.\n     *\n     * @param entries nav selector entries\n     * @param entryUid the entry uid to toggle\n     * @param minified true if the nav selector is minified. Needed for leaf as they are not foldable in minified mode\n     */\n    static toggleFolding<T extends InternalNavSelectorEntry>(\n        entries: T[],\n        entryUid: string,\n        minified: boolean\n    ): InternalNavSelectorEntry[] {\n        return this.toggleEntryFolding(entries, entryUid, minified);\n    }\n\n    /**\n     * Fold an entry.\n     *\n     * Set unfocusable on all children of the folded entry.\n     * Compute whenever the counter and token invalid should be displayed on groups and leaves.\n     *\n     * @param entries nav selector entries\n     * @param entryUid the entry uid to fold\n     * @param minified true if the nav selector is minified. Needed for leaf as they are not foldable in minified mode\n     */\n    static fold<T extends InternalNavSelectorEntry>(entries: T[], entryUid: string, minified: boolean): InternalNavSelectorEntry[] {\n        return this.foldEntry(entries, entryUid, minified);\n    }\n\n    /**\n     * Unfold an entry.\n     *\n     * Set focusable on all children of the folded entry.\n     * Compute whenever the counter and token invalid should be displayed on groups and leaves.\n     *\n     * @param entries nav selector entries\n     * @param entryUid the entry uid to unfold\n     * @param minified true if the nav selector is minified. Needed for leaf as they are not foldable in minified mode\n     */\n    static unfold<T extends InternalNavSelectorEntry>(entries: T[], entryUid: string, minified: boolean): InternalNavSelectorEntry[] {\n        return this.unfoldEntry(entries, entryUid, minified);\n    }\n\n    private static toggleEntryFolding<T extends InternalNavSelectorEntry>(\n        entries: T[],\n        entryUid: string,\n        minified: boolean,\n        parentFolded = false\n    ): InternalNavSelectorEntry[] {\n        return entries.map(entry => {\n            if (isInternalNavSelectorEntryACategory(entry)) {\n                if (entry.uid === entryUid) {\n                    const folded = !entry.folded;\n                    if (folded) {\n                        return this.foldCategory(entry, minified);\n                    } else {\n                        return this.unfoldCategory(entry, minified);\n                    }\n                }\n                return {\n                    ...entry,\n                    children: this.toggleEntryFolding(entry.children, entryUid, minified, entry.folded),\n                };\n            }\n            if (isInternalNavSelectorEntryAGroup(entry)) {\n                if (entry.uid === entryUid) {\n                    const folded = !entry.folded;\n                    if (folded) {\n                        return this.foldGroup(entry, minified);\n                    } else {\n                        return this.unfoldGroup(entry, minified);\n                    }\n                }\n                return {\n                    ...entry,\n                    children: this.toggleEntryFolding(entry.children, entryUid, minified, parentFolded || entry.folded),\n                };\n            }\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                if (entry.uid === entryUid) {\n                    const folded = !entry.folded;\n                    if (folded) {\n                        return this.foldLeaf(entry, minified);\n                    } else {\n                        return this.unfoldLeaf(entry, minified);\n                    }\n                }\n                return {\n                    ...entry,\n                    focusable: isInternalNavSelectorEntryALeafFocusable(entry, { minified, parentFolded }),\n                };\n            }\n            return { ...entry, focusable: !parentFolded };\n        });\n    }\n\n    private static foldEntry<T extends InternalNavSelectorEntry>(\n        entries: T[],\n        entryUid: string,\n        minified: boolean,\n        parentFolded = false\n    ): InternalNavSelectorEntry[] {\n        return entries.map(entry => {\n            if (isInternalNavSelectorEntryACategory(entry)) {\n                if (entry.uid === entryUid) {\n                    return this.foldCategory(entry, minified);\n                }\n                return {\n                    ...entry,\n                    children: this.foldEntry(entry.children, entryUid, minified, entry.folded),\n                };\n            }\n            if (isInternalNavSelectorEntryAGroup(entry)) {\n                if (entry.uid === entryUid) {\n                    return this.foldGroup(entry, minified);\n                }\n                return {\n                    ...entry,\n                    focusable: !parentFolded,\n                    children: this.foldEntry(entry.children, entryUid, minified, parentFolded || entry.folded),\n                };\n            }\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                if (entry.uid === entryUid) {\n                    return this.foldLeaf(entry, minified);\n                }\n                return {\n                    ...entry,\n                    focusable: isInternalNavSelectorEntryALeafFocusable(entry, { minified, parentFolded }),\n                };\n            }\n            return { ...entry, focusable: !parentFolded };\n        });\n    }\n\n    private static unfoldEntry<T extends InternalNavSelectorEntry>(\n        entries: T[],\n        entryUid: string,\n        minified: boolean,\n        parentFolded = false\n    ): InternalNavSelectorEntry[] {\n        return entries.map(entry => {\n            if (isInternalNavSelectorEntryACategory(entry)) {\n                if (entry.uid === entryUid) {\n                    return this.unfoldCategory(entry, minified);\n                }\n                return {\n                    ...entry,\n                    children: this.unfoldEntry(entry.children, entryUid, minified, entry.folded),\n                };\n            }\n            if (isInternalNavSelectorEntryAGroup(entry)) {\n                if (entry.uid === entryUid) {\n                    return this.unfoldGroup(entry, minified);\n                }\n                return {\n                    ...entry,\n                    children: this.unfoldEntry(entry.children, entryUid, minified, parentFolded || entry.folded),\n                    focusable: !parentFolded,\n                };\n            }\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                if (entry.uid === entryUid) {\n                    return this.unfoldLeaf(entry, minified);\n                }\n                return {\n                    ...entry,\n                    focusable: isInternalNavSelectorEntryALeafFocusable(entry, { minified, parentFolded }),\n                };\n            }\n            return { ...entry, focusable: !parentFolded };\n        });\n    }\n\n    private static foldCategory(category: InternalNavSelectorCategory, minified: boolean): InternalNavSelectorCategory {\n        return {\n            ...category,\n            folded: true,\n            children: this.foldEntry(category.children, category.uid, minified, true) as (\n                | InternalNavSelectorLeaf\n                | InternalNavSelectorGroup\n            )[],\n        };\n    }\n\n    private static unfoldCategory(category: InternalNavSelectorCategory, minified: boolean): InternalNavSelectorCategory {\n        return {\n            ...category,\n            folded: false,\n            children: this.unfoldEntry(category.children, category.uid, minified, false) as (\n                | InternalNavSelectorLeaf\n                | InternalNavSelectorGroup\n            )[],\n        };\n    }\n\n    private static foldGroup(group: InternalNavSelectorGroup, minified: boolean): InternalNavSelectorGroup {\n        return {\n            ...group,\n            folded: true,\n            children: this.foldEntry(group.children, group.uid, minified, true) as InternalNavSelectorLeaf[],\n            displayCounter: !!group.counter,\n            displayTokenInvalid: group.children.some(({ displayTokenInvalid }) => displayTokenInvalid),\n        };\n    }\n\n    private static unfoldGroup(group: InternalNavSelectorGroup, minified: boolean): InternalNavSelectorGroup {\n        return {\n            ...group,\n            folded: false,\n            children: this.unfoldEntry(group.children, group.uid, minified, false) as InternalNavSelectorLeaf[],\n            displayCounter: false,\n            displayTokenInvalid: false,\n        };\n    }\n\n    private static foldLeaf(leaf: InternalNavSelectorLeaf, minified: boolean): InternalNavSelectorLeaf {\n        if (!leaf.foldable || minified) {\n            return leaf;\n        }\n        return {\n            ...leaf,\n            displayCounter: true,\n            folded: true,\n            details: leaf.details.map(detail => ({ ...detail, focusable: false })),\n        };\n    }\n\n    private static unfoldLeaf(leaf: InternalNavSelectorLeaf, minified: boolean): InternalNavSelectorLeaf {\n        if (!leaf.foldable || minified) {\n            return leaf;\n        }\n        return {\n            ...leaf,\n            displayCounter: false,\n            folded: false,\n            details: leaf.details.map((detail, idx) => ({\n                ...detail,\n                focusable: idx < leaf.viewMoreDetailsDisplayedLimit,\n            })),\n        };\n    }\n}\n"]}

package/esm2022/nav-selector/utils/nav-selector.minifying.mjs

@@ -0,0 +1,50 @@
+import { isInternalNavSelectorEntryALeafDetails, isInternalNavSelectorEntryANode, } from '../nav-selector';
+import { isInternalNavSelectorEntryALeafFocusable } from '../utils/leaf.utils';
+/**
+ * NavSelectorMinifying is a utility class that provides methods to apply rules on entries when minifying or expanded nav selector.
+ */
+export class NavSelectorMinifying {
+    /**
+     * When minifying the nav selector, compute the focusable state of the entries.
+     *
+     * Leaf are not focusable in any error state when minified.
+     * Detail are not focusable when minified.
+     *
+     * @param entries The entries to minify.
+     * @returns The modified entries.
+     */
+    static minify(entries) {
+        return this.compute(entries, true);
+    }
+    /**
+     * When expanding the nav selector, compute the focusable state of the entries.
+     *
+     * Leaf are not focusable in disabled state when expanded.
+     * Detail are focusable when expanded.
+     *
+     * @param entries The entries to minify.
+     * @returns The modified entries.
+     */
+    static expand(entries) {
+        return this.compute(entries, false);
+    }
+    static compute(entries, minified, parent = null) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryALeafDetails(entry)) {
+                return { ...entry, focusable: !minified };
+            }
+            if (isInternalNavSelectorEntryANode(entry)) {
+                return {
+                    ...entry,
+                    children: this.compute(entry.children, minified, entry),
+                };
+            }
+            return {
+                ...entry,
+                focusable: isInternalNavSelectorEntryALeafFocusable(entry, { parentFolded: parent?.folded === true, minified: minified }),
+                details: this.compute(entry.details, minified),
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2LXNlbGVjdG9yLm1pbmlmeWluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvdWktY29tcG9uZW50cy9uYXYtc2VsZWN0b3Ivc3JjL3V0aWxzL25hdi1zZWxlY3Rvci5taW5pZnlpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUlILHNDQUFzQyxFQUN0QywrQkFBK0IsR0FDbEMsTUFBTSxpQkFBaUIsQ0FBQztBQUN6QixPQUFPLEVBQUUsd0NBQXdDLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUUvRTs7R0FFRztBQUNILE1BQU0sT0FBTyxvQkFBb0I7SUFDN0I7Ozs7Ozs7O09BUUc7SUFDSCxNQUFNLENBQUMsTUFBTSxDQUFxQyxPQUFZO1FBQzFELE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUVEOzs7Ozs7OztPQVFHO0lBQ0gsTUFBTSxDQUFDLE1BQU0sQ0FBcUMsT0FBWTtRQUMxRCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUFFTyxNQUFNLENBQUMsT0FBTyxDQUNsQixPQUFZLEVBQ1osUUFBaUIsRUFDakIsU0FBd0UsSUFBSTtRQUU1RSxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDdkIsSUFBSSxzQ0FBc0MsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO2dCQUNoRCxPQUFPLEVBQUUsR0FBRyxLQUFLLEVBQUUsU0FBUyxFQUFFLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDOUMsQ0FBQztZQUNELElBQUksK0JBQStCLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztnQkFDekMsT0FBTztvQkFDSCxHQUFHLEtBQUs7b0JBQ1IsUUFBUSxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsS0FBSyxDQUFDO2lCQUMxRCxDQUFDO1lBQ04sQ0FBQztZQUVELE9BQU87Z0JBQ0gsR0FBRyxLQUFLO2dCQUNSLFNBQVMsRUFBRSx3Q0FBd0MsQ0FBQyxLQUFLLEVBQUUsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLE1BQU0sS0FBSyxJQUFJLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxDQUFDO2dCQUN6SCxPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQzthQUNqRCxDQUFDO1FBQ04sQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICAgIEludGVybmFsTmF2U2VsZWN0b3JDYXRlZ29yeSxcbiAgICBJbnRlcm5hbE5hdlNlbGVjdG9yRW50cnksXG4gICAgSW50ZXJuYWxOYXZTZWxlY3Rvckdyb3VwLFxuICAgIGlzSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5QUxlYWZEZXRhaWxzLFxuICAgIGlzSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5QU5vZGUsXG59IGZyb20gJy4uL25hdi1zZWxlY3Rvcic7XG5pbXBvcnQgeyBpc0ludGVybmFsTmF2U2VsZWN0b3JFbnRyeUFMZWFmRm9jdXNhYmxlIH0gZnJvbSAnLi4vdXRpbHMvbGVhZi51dGlscyc7XG5cbi8qKlxuICogTmF2U2VsZWN0b3JNaW5pZnlpbmcgaXMgYSB1dGlsaXR5IGNsYXNzIHRoYXQgcHJvdmlkZXMgbWV0aG9kcyB0byBhcHBseSBydWxlcyBvbiBlbnRyaWVzIHdoZW4gbWluaWZ5aW5nIG9yIGV4cGFuZGVkIG5hdiBzZWxlY3Rvci5cbiAqL1xuZXhwb3J0IGNsYXNzIE5hdlNlbGVjdG9yTWluaWZ5aW5nIHtcbiAgICAvKipcbiAgICAgKiBXaGVuIG1pbmlmeWluZyB0aGUgbmF2IHNlbGVjdG9yLCBjb21wdXRlIHRoZSBmb2N1c2FibGUgc3RhdGUgb2YgdGhlIGVudHJpZXMuXG4gICAgICpcbiAgICAgKiBMZWFmIGFyZSBub3QgZm9jdXNhYmxlIGluIGFueSBlcnJvciBzdGF0ZSB3aGVuIG1pbmlmaWVkLlxuICAgICAqIERldGFpbCBhcmUgbm90IGZvY3VzYWJsZSB3aGVuIG1pbmlmaWVkLlxuICAgICAqXG4gICAgICogQHBhcmFtIGVudHJpZXMgVGhlIGVudHJpZXMgdG8gbWluaWZ5LlxuICAgICAqIEByZXR1cm5zIFRoZSBtb2RpZmllZCBlbnRyaWVzLlxuICAgICAqL1xuICAgIHN0YXRpYyBtaW5pZnk8VCBleHRlbmRzIEludGVybmFsTmF2U2VsZWN0b3JFbnRyeT4oZW50cmllczogVFtdKTogSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5W10ge1xuICAgICAgICByZXR1cm4gdGhpcy5jb21wdXRlKGVudHJpZXMsIHRydWUpO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIFdoZW4gZXhwYW5kaW5nIHRoZSBuYXYgc2VsZWN0b3IsIGNvbXB1dGUgdGhlIGZvY3VzYWJsZSBzdGF0ZSBvZiB0aGUgZW50cmllcy5cbiAgICAgKlxuICAgICAqIExlYWYgYXJlIG5vdCBmb2N1c2FibGUgaW4gZGlzYWJsZWQgc3RhdGUgd2hlbiBleHBhbmRlZC5cbiAgICAgKiBEZXRhaWwgYXJlIGZvY3VzYWJsZSB3aGVuIGV4cGFuZGVkLlxuICAgICAqXG4gICAgICogQHBhcmFtIGVudHJpZXMgVGhlIGVudHJpZXMgdG8gbWluaWZ5LlxuICAgICAqIEByZXR1cm5zIFRoZSBtb2RpZmllZCBlbnRyaWVzLlxuICAgICAqL1xuICAgIHN0YXRpYyBleHBhbmQ8VCBleHRlbmRzIEludGVybmFsTmF2U2VsZWN0b3JFbnRyeT4oZW50cmllczogVFtdKTogSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5W10ge1xuICAgICAgICByZXR1cm4gdGhpcy5jb21wdXRlKGVudHJpZXMsIGZhbHNlKTtcbiAgICB9XG5cbiAgICBwcml2YXRlIHN0YXRpYyBjb21wdXRlPFQgZXh0ZW5kcyBJbnRlcm5hbE5hdlNlbGVjdG9yRW50cnk+KFxuICAgICAgICBlbnRyaWVzOiBUW10sXG4gICAgICAgIG1pbmlmaWVkOiBib29sZWFuLFxuICAgICAgICBwYXJlbnQ6IEludGVybmFsTmF2U2VsZWN0b3JHcm91cCB8IEludGVybmFsTmF2U2VsZWN0b3JDYXRlZ29yeSB8IG51bGwgPSBudWxsXG4gICAgKTogSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5W10ge1xuICAgICAgICByZXR1cm4gZW50cmllcy5tYXAoZW50cnkgPT4ge1xuICAgICAgICAgICAgaWYgKGlzSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5QUxlYWZEZXRhaWxzKGVudHJ5KSkge1xuICAgICAgICAgICAgICAgIHJldHVybiB7IC4uLmVudHJ5LCBmb2N1c2FibGU6ICFtaW5pZmllZCB9O1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgaWYgKGlzSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5QU5vZGUoZW50cnkpKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgICAgICAgICAgLi4uZW50cnksXG4gICAgICAgICAgICAgICAgICAgIGNoaWxkcmVuOiB0aGlzLmNvbXB1dGUoZW50cnkuY2hpbGRyZW4sIG1pbmlmaWVkLCBlbnRyeSksXG4gICAgICAgICAgICAgICAgfTtcbiAgICAgICAgICAgIH1cblxuICAgICAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgICAgICAuLi5lbnRyeSxcbiAgICAgICAgICAgICAgICBmb2N1c2FibGU6IGlzSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5QUxlYWZGb2N1c2FibGUoZW50cnksIHsgcGFyZW50Rm9sZGVkOiBwYXJlbnQ/LmZvbGRlZCA9PT0gdHJ1ZSwgbWluaWZpZWQ6IG1pbmlmaWVkIH0pLFxuICAgICAgICAgICAgICAgIGRldGFpbHM6IHRoaXMuY29tcHV0ZShlbnRyeS5kZXRhaWxzLCBtaW5pZmllZCksXG4gICAgICAgICAgICB9O1xuICAgICAgICB9KTtcbiAgICB9XG59XG4iXX0=

package/esm2022/nav-selector/utils/nav-selector.multi-select.mjs

@@ -0,0 +1,208 @@
+import { isInternalNavSelectorEntryACategory, isInternalNavSelectorEntryAGroup, isInternalNavSelectorEntryALeaf, isInternalNavSelectorEntryANode, } from '../nav-selector';
+/**
+ * NavSelectorMultiSelect is a utility class that provides methods to select an entry in multiple mode.
+ */
+export class NavSelectorMultiSelect {
+    /**
+     * Select an entry in multiple mode.
+     *
+     * Categories are not selectable.
+     *
+     * Groups and leaves are selectable.
+     *
+     * Groups may be in undetermined state if some of their children are selected and some are not.
+     * @param entries nav selector entries
+     * @param entryUid the entry uid to select
+     */
+    static selectInMultipleMode(entries, entryUid) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                return this.selectALeafInMultipleMode(entry, entryUid);
+            }
+            else if (isInternalNavSelectorEntryAGroup(entry)) {
+                return this.selectAGroupInMultipleMode(entry, entryUid);
+            }
+            else if (isInternalNavSelectorEntryACategory(entry)) {
+                return this.selectACategoryInMultipleMode(entry, entryUid);
+            }
+            return entry;
+        });
+    }
+    /**
+     * Select only a leaf in multiple mode.
+     *
+     * Categories are not selectable.
+     *
+     * Groups may be in undetermined state if some of their children are selected and some are not.
+     * @param entries nav selector entries
+     * @param entryUid the entry uid to select
+     */
+    static selectOnlyALeafInMultipleMode(entries, entryUid) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                return {
+                    ...entry,
+                    selected: entry.uid === entryUid,
+                };
+            }
+            else if (isInternalNavSelectorEntryACategory(entry)) {
+                return {
+                    ...entry,
+                    children: this.selectOnlyALeafInMultipleMode(entry.children, entryUid),
+                };
+            }
+            else if (isInternalNavSelectorEntryAGroup(entry)) {
+                const children = entry.children.flatMap(child => this.selectOnlyALeafInMultipleMode([child], entryUid));
+                const selected = children.every(child => child.selected || (isInternalNavSelectorEntryALeaf(child) && !child.selectable));
+                return {
+                    ...entry,
+                    children,
+                    selected,
+                    undeterminedSelection: !selected && children.some(child => child.selected),
+                };
+            }
+            return entry;
+        });
+    }
+    /**
+     * Select all entries in multiple mode.
+     *
+     * Categories are not selectable.
+     *
+     * Groups and leaves are selectable.
+     * @param entries nav selector entries
+     */
+    static selectAll(entries) {
+        return this.selectChildren(entries);
+    }
+    /**
+     * Unselect all entries in multiple mode.
+     *
+     * Categories are not selectable.
+     *
+     * Groups and leaves are selectable.
+     * @param entries nav selector entries
+     */
+    static unselectAll(entries) {
+        return this.unselectChildren(entries);
+    }
+    static selectALeafInMultipleMode(leaf, entryUid) {
+        let selected = false;
+        if (leaf.selectable) {
+            selected = leaf.uid === entryUid ? !leaf.selected : leaf.selected;
+        }
+        return {
+            ...leaf,
+            selected,
+        };
+    }
+    static selectACategoryInMultipleMode(entry, entryUid) {
+        return {
+            ...entry,
+            children: entry.children.map(child => {
+                if (isInternalNavSelectorEntryALeaf(child)) {
+                    return this.selectALeafInMultipleMode(child, entryUid);
+                }
+                return this.selectAGroupInMultipleMode(child, entryUid);
+            }),
+        };
+    }
+    static selectAGroupInMultipleMode(entry, entryUid) {
+        if (!entry.selectable) {
+            return entry;
+        }
+        let selected;
+        let children;
+        let undeterminedSelection = false;
+        if (entry.uid === entryUid) {
+            selected = !entry.selected;
+            if (selected) {
+                children = this.selectLeafs(entry.children);
+            }
+            else {
+                children = this.unselectLeafs(entry.children);
+            }
+        }
+        else {
+            children = entry.children.map(child => this.toggleSelectLeaf(child, entryUid));
+            selected = children.every(child => child.selected || (isInternalNavSelectorEntryALeaf(child) && !child.selectable));
+            undeterminedSelection = !selected && children.some(child => child.selected);
+        }
+        return {
+            ...entry,
+            children,
+            selected,
+            undeterminedSelection,
+        };
+    }
+    static toggleSelectLeaf(leaf, uid) {
+        if (leaf.uid === uid) {
+            return {
+                ...leaf,
+                selected: !leaf.selected,
+            };
+        }
+        return leaf;
+    }
+    static selectLeafs(leafs) {
+        return leafs.map(leaf => ({
+            ...leaf,
+            selected: true,
+        }));
+    }
+    static unselectLeafs(leafs) {
+        return leafs.map(leaf => ({
+            ...leaf,
+            selected: false,
+        }));
+    }
+    static unselectChildren(entry) {
+        return entry.map(child => {
+            if (isInternalNavSelectorEntryALeaf(child)) {
+                return {
+                    ...child,
+                    selected: false,
+                };
+            }
+            else if (isInternalNavSelectorEntryACategory(child)) {
+                return {
+                    ...child,
+                    children: this.unselectChildren(child.children),
+                };
+            }
+            else if (isInternalNavSelectorEntryANode(child)) {
+                return {
+                    ...child,
+                    children: this.unselectChildren(child.children),
+                    selected: false,
+                };
+            }
+            return child;
+        });
+    }
+    static selectChildren(entry) {
+        return entry.map(child => {
+            if (isInternalNavSelectorEntryALeaf(child)) {
+                return {
+                    ...child,
+                    selected: child.selectable,
+                };
+            }
+            else if (isInternalNavSelectorEntryACategory(child)) {
+                return {
+                    ...child,
+                    children: this.selectChildren(child.children),
+                };
+            }
+            else if (isInternalNavSelectorEntryAGroup(child)) {
+                return {
+                    ...child,
+                    children: this.selectChildren(child.children),
+                    selected: true,
+                };
+            }
+            return child;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-selector.multi-select.js","sourceRoot":"","sources":["../../../../../libs/ui-components/nav-selector/src/utils/nav-selector.multi-select.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    InternalNavSelectorCategory,\n    InternalNavSelectorEntry,\n    InternalNavSelectorGroup,\n    InternalNavSelectorLeaf,\n    isInternalNavSelectorEntryACategory,\n    isInternalNavSelectorEntryAGroup,\n    isInternalNavSelectorEntryALeaf,\n    isInternalNavSelectorEntryANode,\n} from '../nav-selector';\n\n/**\n * NavSelectorMultiSelect is a utility class that provides methods to select an entry in multiple mode.\n */\nexport class NavSelectorMultiSelect {\n    /**\n     * Select an entry in multiple mode.\n     *\n     * Categories are not selectable.\n     *\n     * Groups and leaves are selectable.\n     *\n     * Groups may be in undetermined state if some of their children are selected and some are not.\n     * @param entries nav selector entries\n     * @param entryUid the entry uid to select\n     */\n    static selectInMultipleMode(entries: InternalNavSelectorEntry[], entryUid: string): InternalNavSelectorEntry[] {\n        return entries.map(entry => {\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                return this.selectALeafInMultipleMode(entry, entryUid);\n            } else if (isInternalNavSelectorEntryAGroup(entry)) {\n                return this.selectAGroupInMultipleMode(entry, entryUid);\n            } else if (isInternalNavSelectorEntryACategory(entry)) {\n                return this.selectACategoryInMultipleMode(entry, entryUid);\n            }\n            return entry;\n        });\n    }\n\n    /**\n     * Select only a leaf in multiple mode.\n     *\n     * Categories are not selectable.\n     *\n     * Groups may be in undetermined state if some of their children are selected and some are not.\n     * @param entries nav selector entries\n     * @param entryUid the entry uid to select\n     */\n    static selectOnlyALeafInMultipleMode<T extends InternalNavSelectorEntry>(entries: T[], entryUid: string): InternalNavSelectorEntry[] {\n        return entries.map(entry => {\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                return {\n                    ...entry,\n                    selected: entry.uid === entryUid,\n                };\n            } else if (isInternalNavSelectorEntryACategory(entry)) {\n                return {\n                    ...entry,\n                    children: this.selectOnlyALeafInMultipleMode(entry.children, entryUid),\n                };\n            } else if (isInternalNavSelectorEntryAGroup(entry)) {\n                const children = entry.children.flatMap(\n                    child => this.selectOnlyALeafInMultipleMode([child], entryUid) as InternalNavSelectorLeaf[]\n                );\n                const selected = children.every(child => child.selected || (isInternalNavSelectorEntryALeaf(child) && !child.selectable));\n                return {\n                    ...entry,\n                    children,\n                    selected,\n                    undeterminedSelection: !selected && children.some(child => child.selected),\n                };\n            }\n            return entry;\n        });\n    }\n\n    /**\n     * Select all entries in multiple mode.\n     *\n     * Categories are not selectable.\n     *\n     * Groups and leaves are selectable.\n     * @param entries nav selector entries\n     */\n    static selectAll(entries: InternalNavSelectorEntry[]): InternalNavSelectorEntry[] {\n        return this.selectChildren(entries);\n    }\n\n    /**\n     * Unselect all entries in multiple mode.\n     *\n     * Categories are not selectable.\n     *\n     * Groups and leaves are selectable.\n     * @param entries nav selector entries\n     */\n    static unselectAll(entries: InternalNavSelectorEntry[]): InternalNavSelectorEntry[] {\n        return this.unselectChildren(entries);\n    }\n\n    private static selectALeafInMultipleMode(leaf: InternalNavSelectorLeaf, entryUid: string): InternalNavSelectorLeaf {\n        let selected = false;\n        if (leaf.selectable) {\n            selected = leaf.uid === entryUid ? !leaf.selected : leaf.selected;\n        }\n        return {\n            ...leaf,\n            selected,\n        };\n    }\n\n    private static selectACategoryInMultipleMode(entry: InternalNavSelectorCategory, entryUid: string): InternalNavSelectorCategory {\n        return {\n            ...entry,\n            children: entry.children.map(child => {\n                if (isInternalNavSelectorEntryALeaf(child)) {\n                    return this.selectALeafInMultipleMode(child, entryUid);\n                }\n                return this.selectAGroupInMultipleMode(child, entryUid);\n            }),\n        };\n    }\n\n    private static selectAGroupInMultipleMode(entry: InternalNavSelectorGroup, entryUid: string): InternalNavSelectorGroup {\n        if (!entry.selectable) {\n            return entry;\n        }\n        let selected: boolean;\n        let children: InternalNavSelectorLeaf[];\n        let undeterminedSelection = false;\n        if (entry.uid === entryUid) {\n            selected = !entry.selected;\n            if (selected) {\n                children = this.selectLeafs(entry.children);\n            } else {\n                children = this.unselectLeafs(entry.children);\n            }\n        } else {\n            children = entry.children.map(child => this.toggleSelectLeaf(child, entryUid));\n            selected = children.every(child => child.selected || (isInternalNavSelectorEntryALeaf(child) && !child.selectable));\n            undeterminedSelection = !selected && children.some(child => child.selected);\n        }\n\n        return {\n            ...entry,\n            children,\n            selected,\n            undeterminedSelection,\n        };\n    }\n\n    private static toggleSelectLeaf(leaf: InternalNavSelectorLeaf, uid: string): InternalNavSelectorLeaf {\n        if (leaf.uid === uid) {\n            return {\n                ...leaf,\n                selected: !leaf.selected,\n            };\n        }\n        return leaf;\n    }\n\n    private static selectLeafs(leafs: InternalNavSelectorLeaf[]): InternalNavSelectorLeaf[] {\n        return leafs.map(leaf => ({\n            ...leaf,\n            selected: true,\n        }));\n    }\n\n    private static unselectLeafs(leafs: InternalNavSelectorLeaf[]): InternalNavSelectorLeaf[] {\n        return leafs.map(leaf => ({\n            ...leaf,\n            selected: false,\n        }));\n    }\n\n    private static unselectChildren<T extends InternalNavSelectorEntry>(entry: T[]): InternalNavSelectorEntry[] {\n        return entry.map(child => {\n            if (isInternalNavSelectorEntryALeaf(child)) {\n                return {\n                    ...child,\n                    selected: false,\n                };\n            } else if (isInternalNavSelectorEntryACategory(child)) {\n                return {\n                    ...child,\n                    children: this.unselectChildren(child.children),\n                };\n            } else if (isInternalNavSelectorEntryANode(child)) {\n                return {\n                    ...child,\n                    children: this.unselectChildren(child.children),\n                    selected: false,\n                };\n            }\n            return child;\n        });\n    }\n\n    private static selectChildren<T extends InternalNavSelectorEntry>(entry: T[]): InternalNavSelectorEntry[] {\n        return entry.map(child => {\n            if (isInternalNavSelectorEntryALeaf(child)) {\n                return {\n                    ...child,\n                    selected: child.selectable,\n                };\n            } else if (isInternalNavSelectorEntryACategory(child)) {\n                return {\n                    ...child,\n                    children: this.selectChildren(child.children),\n                };\n            } else if (isInternalNavSelectorEntryAGroup(child)) {\n                return {\n                    ...child,\n                    children: this.selectChildren(child.children),\n                    selected: true,\n                };\n            }\n            return child;\n        });\n    }\n}\n"]}