@ojiepermana/angular 22.1.10 → 22.1.12

package/fesm2022/ojiepermana-angular-navigation-service.mjs

@@ -1,7 +1,729 @@
-export * from '@ojiepermana/angular-navigation/service';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from '@angular/core';
+import { inject, signal, computed, isDevMode, Service } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { DefaultUrlSerializer, UrlTree, PRIMARY_OUTLET, Router, NavigationEnd } from '@angular/router';
+import { documentLocalStorage } from '@ojiepermana/angular/component/utils/core';
 
-// Generated by scripts/gen-umbrella-entrypoints.mjs — do not edit by hand.
+const DEFAULT_NAVIGATION_ID = 'default';
+const PERSISTED_NAVIGATION_ID = 'main';
+const INSTANCE_STORAGE_PROPERTIES = [
+    'orientation',
+    'appearance',
+    'position',
+    'collapsed',
+    'dockbar-mode',
+];
+const TYPE_MODE_STORAGE_KEY = 'nav-type-mode';
+/** Resolves and persists the small navigation state contract without owning UI state. */
+class NavigationPersistence {
+    documentRef;
+    /**
+     * The same never-throwing localStorage wrapper the theme axes use. It lives in
+     * `component/utils/core` rather than in the theme package precisely so this
+     * class can share it: navigation must not depend on theme, which already
+     * depends on navigation.
+     */
+    storageRef;
+    constructor(documentRef) {
+        this.documentRef = documentRef;
+        this.storageRef = documentLocalStorage(documentRef);
+    }
+    resolveState(input) {
+        const id = this.normalizeId(input.id);
+        const orientation = input.orientation;
+        const type = this.resolveType(id, orientation, input.type);
+        return {
+            id,
+            orientation,
+            type,
+            position: this.resolvePosition(id, orientation, input.position),
+            collapsed: this.resolveCollapsed(id, type, input.collapsed),
+            dockbarMode: this.resolveDockbarMode(id, type, input.dockbarMode),
+        };
+    }
+    persistState(state) {
+        if (state.id !== PERSISTED_NAVIGATION_ID) {
+            this.clearLegacyInstanceStorage(state.id);
+            return;
+        }
+        this.writeStorage(this.persistedStorageKey('orientation'), state.orientation);
+        this.writeStorage(this.persistedStorageKey('type'), state.type);
+        this.writeStorage(this.persistedStorageKey('position'), state.position);
+        this.writeStorage(TYPE_MODE_STORAGE_KEY, this.persistedTypeMode(state));
+    }
+    normalizeId(id) {
+        return id.trim() || DEFAULT_NAVIGATION_ID;
+    }
+    resolveType(id, orientation, type) {
+        if (this.isTypeForOrientation(type, orientation))
+            return type;
+        const stored = this.readInstanceStorage(id, 'type');
+        if (this.isTypeForOrientation(stored, orientation))
+            return stored;
+        return orientation === 'vertical' ? 'sidebar' : 'navbar';
+    }
+    resolvePosition(id, orientation, position) {
+        if (this.isPositionForOrientation(position, orientation))
+            return position;
+        const stored = this.readInstanceStorage(id, 'position');
+        if (this.isPositionForOrientation(stored, orientation))
+            return stored;
+        return orientation === 'horizontal' ? 'top' : 'left';
+    }
+    resolveCollapsed(id, type, collapsed) {
+        if (typeof collapsed === 'boolean')
+            return collapsed;
+        return type === 'sidebar' && this.readPersistedTypeMode(id) === 'collapsed';
+    }
+    resolveDockbarMode(id, type, mode) {
+        if (this.isDockbarMode(mode))
+            return mode;
+        if (type !== 'dockbar')
+            return 'sticky';
+        const stored = this.readPersistedTypeMode(id);
+        return this.isDockbarMode(stored) ? stored : 'sticky';
+    }
+    readStorage(key) {
+        return this.storageRef.read(key);
+    }
+    readInstanceStorage(id, property) {
+        return id === PERSISTED_NAVIGATION_ID
+            ? this.readStorage(this.persistedStorageKey(property))
+            : null;
+    }
+    readPersistedTypeMode(id) {
+        if (id !== PERSISTED_NAVIGATION_ID)
+            return null;
+        const stored = this.readStorage(TYPE_MODE_STORAGE_KEY);
+        return this.isPersistedTypeMode(stored) ? stored : null;
+    }
+    writeStorage(key, value) {
+        this.storageRef.write(key, value);
+    }
+    removeStorage(key) {
+        this.storageRef.remove(key);
+    }
+    clearLegacyInstanceStorage(id) {
+        for (const property of INSTANCE_STORAGE_PROPERTIES) {
+            this.removeStorage(`nav:${id}:${property}`);
+        }
+    }
+    persistedStorageKey(property) {
+        return `nav-${property}`;
+    }
+    persistedTypeMode(state) {
+        if (state.type === 'dockbar')
+            return state.dockbarMode;
+        return state.collapsed ? 'collapsed' : 'default';
+    }
+    isPersistedTypeMode(value) {
+        return value === 'default' || value === 'collapsed' || this.isDockbarMode(value);
+    }
+    isTypeForOrientation(value, orientation) {
+        return orientation === 'vertical'
+            ? value === 'sidebar' || value === 'dockbar'
+            : value === 'navbar' || value === 'flyout';
+    }
+    isPositionForOrientation(value, orientation) {
+        return orientation === 'vertical'
+            ? value === 'left' || value === 'right'
+            : value === 'top' || value === 'bottom';
+    }
+    isDockbarMode(value) {
+        return value === 'drawer' || value === 'sticky';
+    }
+}
+
+/**
+ * Turns navigation items into `UrlTree`s and matches them against the active
+ * URL. Both halves are memoized: the active URL is parsed once per walk, and an
+ * item's own tree is cached against the item, because `Router.createUrlTree` is
+ * the expensive half and a plain absolute link resolves to the same tree for the
+ * life of that item. The cache is keyed by the normalized item, so it is
+ * discarded with the item the moment `normalizeUiNavItems` runs again.
+ */
+class NavigationActiveUrlResolver {
+    router;
+    urlSerializer = new DefaultUrlSerializer();
+    itemUrlTrees = new WeakMap();
+    activeUrlTree = null;
+    constructor(router) {
+        this.router = router;
+    }
+    match(activeUrl, routerUrl, relativeTo) {
+        return { activeUrl, activeTree: this.parseActiveUrl(activeUrl), relativeTo, routerUrl };
+    }
+    matches(item, match, options) {
+        const activeTree = match.activeTree;
+        if (!item.link || item.externalLink || activeTree === null) {
+            return false;
+        }
+        const itemTree = this.cachedItemUrlTree(item, match, activeTree);
+        return itemTree === null ? false : containsNavigationUrlTree(activeTree, itemTree, options);
+    }
+    cachedItemUrlTree(item, match, activeTree) {
+        if (match.relativeTo !== null) {
+            return this.itemUrlTree(item, activeTree, match.relativeTo);
+        }
+        const key = this.dependsOnActiveUrl(item) ? `${match.activeUrl} ${match.routerUrl}` : null;
+        const cached = this.itemUrlTrees.get(item);
+        if (cached !== undefined && cached.key === key) {
+            return cached.tree;
+        }
+        const tree = this.itemUrlTree(item, activeTree, null);
+        this.itemUrlTrees.set(item, { key, tree });
+        return tree;
+    }
+    /** A relative or query/fragment-inheriting link resolves against the live URL. */
+    dependsOnActiveUrl(item) {
+        if (item.preserveFragment === true ||
+            item.queryParamsHandling === 'preserve' ||
+            item.queryParamsHandling === 'merge') {
+            return true;
+        }
+        const link = item.link;
+        if (link instanceof UrlTree) {
+            return false;
+        }
+        if (typeof link === 'string') {
+            return !link.startsWith('/');
+        }
+        const first = Array.isArray(link) ? link[0] : undefined;
+        return !(typeof first === 'string' && first.startsWith('/'));
+    }
+    parseActiveUrl(url) {
+        if (this.activeUrlTree !== null && this.activeUrlTree.url === url) {
+            return this.activeUrlTree.tree;
+        }
+        const tree = this.parseUrl(url);
+        this.activeUrlTree = { url, tree };
+        return tree;
+    }
+    itemUrlTree(item, activeTree, relativeTo) {
+        const link = item.link;
+        if (!link) {
+            return null;
+        }
+        if (link instanceof UrlTree) {
+            return link;
+        }
+        if (this.router !== null) {
+            try {
+                const commands = typeof link === 'string' ? [link] : Array.from(link);
+                return this.router.createUrlTree(commands, {
+                    relativeTo,
+                    queryParams: item.queryParams,
+                    queryParamsHandling: item.queryParamsHandling,
+                    fragment: item.fragment,
+                    preserveFragment: item.preserveFragment,
+                });
+            }
+            catch {
+                return null;
+            }
+        }
+        const baseTree = typeof link === 'string' ? this.parseUrl(link) : null;
+        return baseTree === null ? null : this.applyRouteExtras(baseTree, item, activeTree);
+    }
+    applyRouteExtras(baseTree, item, activeTree) {
+        const handling = item.queryParamsHandling ?? 'replace';
+        let queryParams = baseTree.queryParams;
+        if (handling === 'preserve') {
+            queryParams = activeTree.queryParams;
+        }
+        else if (handling === 'merge') {
+            queryParams = { ...activeTree.queryParams, ...(item.queryParams ?? {}) };
+        }
+        else if (item.queryParams !== undefined) {
+            queryParams = item.queryParams ?? {};
+        }
+        const fragment = item.preserveFragment
+            ? activeTree.fragment
+            : (item.fragment ?? baseTree.fragment);
+        try {
+            // Serialize + parse normalizes numeric/array query values exactly as the
+            // Router does before applying IsActiveMatchOptions.
+            return this.urlSerializer.parse(this.urlSerializer.serialize(new UrlTree(baseTree.root, queryParams, fragment)));
+        }
+        catch {
+            return null;
+        }
+    }
+    parseUrl(url) {
+        try {
+            return this.router?.parseUrl(url) ?? this.urlSerializer.parse(url);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** Pure equivalent of Router's UrlTree containment semantics for an explicit active URL. */
+function containsNavigationUrlTree(container, containee, options) {
+    return (segmentGroupsMatch(container.root, containee.root, options.paths, options.matrixParams) &&
+        paramsMatch(container.queryParams, containee.queryParams, options.queryParams) &&
+        (options.fragment === 'ignored' || container.fragment === containee.fragment));
+}
+function segmentGroupsMatch(container, containee, paths, matrixParams) {
+    return paths === 'exact'
+        ? equalSegmentGroups(container, containee, matrixParams)
+        : containsSegmentGroup(container, containee, matrixParams);
+}
+function equalSegmentGroups(container, containee, matrixParams) {
+    if (!equalPaths(container.segments, containee.segments) ||
+        !matrixParamsMatch(container.segments, containee.segments, matrixParams) ||
+        container.numberOfChildren !== containee.numberOfChildren) {
+        return false;
+    }
+    return Object.entries(containee.children).every(([outlet, child]) => container.children[outlet] !== undefined &&
+        equalSegmentGroups(container.children[outlet], child, matrixParams));
+}
+function containsSegmentGroup(container, containee, matrixParams) {
+    return containsSegmentGroupPaths(container, containee, containee.segments, matrixParams);
+}
+function containsSegmentGroupPaths(container, containee, containeePaths, matrixParams) {
+    if (container.segments.length > containeePaths.length) {
+        const current = container.segments.slice(0, containeePaths.length);
+        return (equalPaths(current, containeePaths) &&
+            !containee.hasChildren() &&
+            matrixParamsMatch(current, containeePaths, matrixParams));
+    }
+    if (container.segments.length === containeePaths.length) {
+        if (!equalPaths(container.segments, containeePaths) ||
+            !matrixParamsMatch(container.segments, containeePaths, matrixParams)) {
+            return false;
+        }
+        return Object.entries(containee.children).every(([outlet, child]) => container.children[outlet] !== undefined &&
+            containsSegmentGroup(container.children[outlet], child, matrixParams));
+    }
+    const current = containeePaths.slice(0, container.segments.length);
+    const next = containeePaths.slice(container.segments.length);
+    const primary = container.children[PRIMARY_OUTLET];
+    return (equalPaths(container.segments, current) &&
+        matrixParamsMatch(container.segments, current, matrixParams) &&
+        primary !== undefined &&
+        containsSegmentGroupPaths(primary, containee, next, matrixParams));
+}
+function matrixParamsMatch(container, containee, strategy) {
+    return containee.every((segment, index) => paramsMatch(container[index]?.parameters ?? {}, segment.parameters, strategy));
+}
+function paramsMatch(container, containee, strategy) {
+    if (strategy === 'ignored') {
+        return true;
+    }
+    const containeeKeys = Object.keys(containee);
+    if (strategy === 'exact' && Object.keys(container).length !== containeeKeys.length) {
+        return false;
+    }
+    if (strategy === 'subset' && Object.keys(container).length < containeeKeys.length) {
+        return false;
+    }
+    return containeeKeys.every((key) => equalParamValue(container[key], containee[key]));
+}
+function equalParamValue(left, right) {
+    if (Array.isArray(left) && Array.isArray(right)) {
+        if (left.length !== right.length) {
+            return false;
+        }
+        const sortedLeft = [...left].sort();
+        const sortedRight = [...right].sort();
+        return sortedLeft.every((value, index) => value === sortedRight[index]);
+    }
+    return left === right;
+}
+function equalPaths(left, right) {
+    return (left.length === right.length &&
+        left.every((segment, index) => segment.path === right[index]?.path));
+}
+
+/** Referensi stabil untuk id yang belum punya data terdaftar (hindari array baru tiap evaluasi). */
+const EMPTY_NAV_DATA = Object.freeze([]);
+class NavigationService {
+    documentRef = inject(DOCUMENT, { optional: true });
+    persistence = new NavigationPersistence(this.documentRef);
+    router = inject(Router, { optional: true });
+    urlResolver = new NavigationActiveUrlResolver(this.router);
+    routerUrl = signal(this.router?.url ?? '/', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "routerUrl" }] : /* istanbul ignore next */ []));
+    states = signal({}, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "states" }] : /* istanbul ignore next */ []));
+    openPanelKeys = signal({}, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "openPanelKeys" }] : /* istanbul ignore next */ []));
+    drawerOpenState = signal({}, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "drawerOpenState" }] : /* istanbul ignore next */ []));
+    /** Data mentah per id, dipublikasikan oleh `<Navigation>` agar surface lain (mis. apps-launcher di `Page`) bisa membaca nav by id tanpa mendaftarkan ulang id yang sama. */
+    dataById = signal({}, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "dataById" }] : /* istanbul ignore next */ []));
+    /** Semua publisher hidup per data id. Publisher terakhir menjadi sumber aktif; cleanup owner lama tidak boleh menghapus publisher baru. */
+    dataPublishers = new Map();
+    /** Token stabil untuk pemanggil legacy yang tidak mengirim owner. */
+    ownerlessDataPublisher = {};
+    /** id navigasi → token owner instance, untuk menjaga setiap id hanya dipakai satu <Navigation> hidup. */
+    idOwners = new Map();
+    openPanelKey = computed(() => this.openPanelKeys()[DEFAULT_NAVIGATION_ID] ?? null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "openPanelKey" }] : /* istanbul ignore next */ []));
+    /** Route aktif yang sudah dinormalisasi untuk consumer dockbar route-aware. */
+    routeContext = computed(() => {
+        const url = this.routerUrl();
+        return this.readRouteContext(url);
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "routeContext" }] : /* istanbul ignore next */ []));
+    exactMatchOptions = {
+        paths: 'exact',
+        queryParams: 'exact',
+        fragment: 'exact',
+        matrixParams: 'exact',
+    };
+    subsetMatchOptions = {
+        paths: 'subset',
+        queryParams: 'subset',
+        fragment: 'ignored',
+        matrixParams: 'ignored',
+    };
+    constructor() {
+        this.router?.events.pipe(takeUntilDestroyed()).subscribe((event) => {
+            if (event instanceof NavigationEnd) {
+                const previousUrl = this.routerUrl();
+                this.routerUrl.set(event.urlAfterRedirects);
+                if (this.urlPath(previousUrl) !== this.urlPath(event.urlAfterRedirects)) {
+                    this.releasePanelsAfterNavigation();
+                }
+            }
+        });
+    }
+    /**
+     * Panel eksplisit (klik trigger rail/navbar) adalah state telusur sementara.
+     * Perpindahan path harus mengembalikan panel ke resolusi URL: tanpa pelepasan
+     * ini, dockbar sticky terkunci pada group lama sampai browser di-refresh,
+     * karena `resolveDockbarGroup` memprioritaskan panel key di atas pencocokan
+     * URL. Navigasi yang hanya mengubah query/fragment tidak melepas panel agar
+     * penelusuran group lain tidak tersentak oleh update background (mis. sort
+     * state yang ditulis ke query params).
+     */
+    releasePanelsAfterNavigation() {
+        this.openPanelKeys.update((state) => Object.values(state).some((key) => key !== null) ? {} : state);
+    }
+    urlPath(url) {
+        const end = url.search(/[?#]/);
+        return end === -1 ? url : url.slice(0, end);
+    }
+    readRouteContext(url) {
+        let snapshot = this.router?.routerState.snapshot.root ?? null;
+        let icon = null;
+        let badge = null;
+        let label = null;
+        while (snapshot !== null) {
+            const data = snapshot.data;
+            if (Object.prototype.hasOwnProperty.call(data, 'navigationIcon')) {
+                icon = this.optionalString(data.navigationIcon);
+            }
+            if (Object.prototype.hasOwnProperty.call(data, 'navigationBadge')) {
+                badge = this.optionalString(data.navigationBadge);
+            }
+            if (Object.prototype.hasOwnProperty.call(data, 'navigationLabel')) {
+                label = this.optionalString(data.navigationLabel);
+            }
+            else if (snapshot.title) {
+                label = snapshot.title;
+            }
+            snapshot =
+                snapshot.children.find((child) => child.outlet === PRIMARY_OUTLET) ??
+                    snapshot.firstChild ??
+                    null;
+        }
+        return { url, icon, badge, label };
+    }
+    optionalString(value) {
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    register(input, owner) {
+        const state = this.persistence.resolveState(input);
+        this.claimId(state.id, owner);
+        this.states.update((states) => ({ ...states, [state.id]: state }));
+        this.persistence.persistState(state);
+        return state;
+    }
+    unregister(id, owner) {
+        const navId = this.persistence.normalizeId(id);
+        this.releaseId(navId, owner);
+        this.states.update((states) => this.withoutKey(states, navId));
+        this.openPanelKeys.update((state) => this.withoutKey(state, navId));
+        this.drawerOpenState.update((state) => this.withoutKey(state, navId));
+    }
+    /**
+     * Validasi keunikan id navigasi: setiap instance `<Navigation>` wajib memakai id unik.
+     * `owner` adalah token unik per instance — klaim ulang oleh owner yang sama (mis. perubahan
+     * input) diizinkan, tetapi dua instance hidup dengan id sama dianggap salah konfigurasi dan
+     * melempar error di mode dev. Pemanggil tanpa owner (akses langsung service) dilewati.
+     */
+    claimId(id, owner) {
+        if (owner === undefined) {
+            return;
+        }
+        const currentOwner = this.idOwners.get(id);
+        if (currentOwner !== undefined && currentOwner !== owner && isDevMode()) {
+            throw new Error(`[Navigation] Duplikasi id navigasi "${id}". Setiap <Navigation> wajib memakai id unik. ` +
+                `Id "main" dikhususkan untuk navigasi utama pada layout/shell (block-shell).`);
+        }
+        this.idOwners.set(id, owner);
+    }
+    releaseId(id, owner) {
+        if (owner === undefined || this.idOwners.get(id) === owner) {
+            this.idOwners.delete(id);
+        }
+    }
+    state(id) {
+        const navId = this.persistence.normalizeId(id);
+        return computed(() => this.states()[navId] ?? null);
+    }
+    currentState(id) {
+        return this.states()[this.persistence.normalizeId(id)] ?? null;
+    }
+    /** Data terdaftar untuk sebuah id sebagai signal; `[]` bila belum ada `<Navigation>` dengan id tersebut. */
+    data(id) {
+        const navId = this.persistence.normalizeId(id);
+        return computed(() => this.dataById()[navId] ?? EMPTY_NAV_DATA);
+    }
+    /** Dipanggil `<Navigation>` untuk mempublikasikan datanya ke registry by id. */
+    publishData(id, data, owner) {
+        const navId = this.persistence.normalizeId(id);
+        const publisher = owner ?? this.ownerlessDataPublisher;
+        const publishers = this.dataPublishers.get(navId) ?? new Map();
+        // Map mempertahankan insertion order. Re-publish oleh owner yang sama harus menjadi
+        // publisher terbaru agar data input yang berubah langsung menjadi sumber aktif.
+        publishers.delete(publisher);
+        publishers.set(publisher, data);
+        this.dataPublishers.set(navId, publishers);
+        this.dataById.update((map) => ({ ...map, [navId]: data }));
+    }
+    /** Dipanggil `<Navigation>` saat destroy untuk melepas datanya dari registry. */
+    clearData(id, owner) {
+        const navId = this.persistence.normalizeId(id);
+        const publisher = owner ?? this.ownerlessDataPublisher;
+        const publishers = this.dataPublishers.get(navId);
+        if (!publishers?.delete(publisher)) {
+            return;
+        }
+        const remaining = Array.from(publishers.values());
+        const fallback = remaining.at(-1);
+        if (fallback) {
+            this.dataById.update((map) => ({ ...map, [navId]: fallback }));
+            return;
+        }
+        this.dataPublishers.delete(navId);
+        this.dataById.update((map) => this.withoutKey(map, navId));
+    }
+    currentPanelKey(id) {
+        return this.openPanelKeys()[this.persistence.normalizeId(id)] ?? null;
+    }
+    update(id, patch) {
+        const navId = this.persistence.normalizeId(id);
+        const current = this.states()[navId] ??
+            this.persistence.resolveState({ id: navId, orientation: patch.orientation ?? 'vertical' });
+        return this.register({
+            id: navId,
+            orientation: patch.orientation ?? current.orientation,
+            type: patch.type ?? current.type,
+            position: patch.position ?? current.position,
+            collapsed: patch.collapsed ?? current.collapsed,
+            dockbarMode: patch.dockbarMode ?? current.dockbarMode,
+        });
+    }
+    setType(id, type) {
+        return this.update(id, { type });
+    }
+    setPosition(id, position) {
+        return this.update(id, { position });
+    }
+    setCollapsed(id, collapsed) {
+        return this.update(id, { collapsed });
+    }
+    toggleCollapsed(id) {
+        const navId = this.persistence.normalizeId(id);
+        const current = this.states()[navId] ?? this.persistence.resolveState({ id: navId, orientation: 'vertical' });
+        return this.setCollapsed(navId, !current.collapsed);
+    }
+    setDockbarMode(id, mode) {
+        return this.update(id, { dockbarMode: mode });
+    }
+    isRouterItem(item) {
+        return !!item.link && !item.externalLink;
+    }
+    hrefFor(item) {
+        if (item.href) {
+            return item.href;
+        }
+        if (item.externalLink && typeof item.link === 'string') {
+            return item.link;
+        }
+        return null;
+    }
+    /**
+     * A consumer `rel` is unioned with the safe default rather than replacing it:
+     * returning `rel="external"` verbatim on a `_blank` link dropped `noopener`
+     * and handed the opened page a live `window.opener`.
+     */
+    relFor(item) {
+        const consumerTokens = item.rel?.split(/\s+/).filter(Boolean) ?? [];
+        if (item.target !== '_blank' && !item.externalLink) {
+            return consumerTokens.length > 0 ? consumerTokens.join(' ') : null;
+        }
+        const tokens = new Set(consumerTokens);
+        tokens.add('noopener');
+        tokens.add('noreferrer');
+        return [...tokens].join(' ');
+    }
+    routerLinkActiveOptions(item) {
+        return (item.isActiveMatchOptions ??
+            (item.exactMatch ? this.exactMatchOptions : this.subsetMatchOptions));
+    }
+    itemRole(orientation, level) {
+        void level;
+        // Horizontal navs are menubars/menus (arrow-key roving) → menuitem. Vertical
+        // navs are plain lists of links (tab navigation, no menu keyboard model), so
+        // their items must NOT be menuitems — a menuitem inside a `list` is an invalid
+        // ARIA parent (axe `aria-required-parent`).
+        return orientation === 'horizontal' ? 'menuitem' : null;
+    }
+    compactLabel(item, compact) {
+        return compact ? (item.tooltip ?? item.title ?? null) : null;
+    }
+    titleFor(item, compact) {
+        return item.tooltip ?? (compact ? (item.title ?? null) : null);
+    }
+    compactFallback(item) {
+        return (item.title ?? item.id ?? '?').trim().slice(0, 2);
+    }
+    iconContext(item, active, level, orientation) {
+        return {
+            $implicit: item.icon ?? '',
+            icon: item.icon ?? '',
+            item: item.source,
+            active,
+            orientation,
+            level,
+        };
+    }
+    isItemActive(item, activeIds, explicitActiveUrl) {
+        return this.matchesActiveTreeDeep(item, activeIds, this.activeMatch(explicitActiveUrl, null));
+    }
+    /**
+     * Pencocokan route murni untuk state dockbar berbasis Router. Berbeda dari
+     * `isItemActive`, konfigurasi legacy `item.active` dan `activeIds` sengaja
+     * tidak ikut menentukan group route aktif.
+     */
+    isItemRouteActive(item, explicitActiveUrl, relativeTo = null) {
+        return this.matchesActiveTreeDeep(item, null, this.activeMatch(explicitActiveUrl, relativeTo));
+    }
+    matchesActiveTreeDeep(item, activeIds, match) {
+        if (activeIds !== null &&
+            (item.active || activeIds.has(item.stateId) || activeIds.has(item.key))) {
+            return true;
+        }
+        if (this.matchesActiveTree(item, match)) {
+            return true;
+        }
+        return item.children.some((child) => this.matchesActiveTreeDeep(child, activeIds, match));
+    }
+    /**
+     * The active URL is parsed once per top-level call and handed down the
+     * recursion; re-parsing it at every node turned one navigation into hundreds
+     * of identical `parseUrl` calls.
+     */
+    activeMatch(explicitActiveUrl, relativeTo) {
+        // Always read the signal so computed callers invalidate on NavigationEnd,
+        // even when Router.url is the fresher synchronous value.
+        const cachedUrl = this.routerUrl();
+        const activeUrl = explicitActiveUrl ?? this.router?.url ?? cachedUrl;
+        return this.urlResolver.match(activeUrl, this.router?.url ?? cachedUrl, relativeTo);
+    }
+    isPanelOpen(navIdOrItem, item) {
+        const { navId, navItem } = this.resolvePanelArgs('isPanelOpen', navIdOrItem, item);
+        return this.openPanelKeys()[navId] === navItem.key;
+    }
+    openPanel(navIdOrItem, item) {
+        const { navId, navItem } = this.resolvePanelArgs('openPanel', navIdOrItem, item);
+        if (navItem.disabled) {
+            return;
+        }
+        this.openPanelKeys.update((state) => ({ ...state, [navId]: navItem.key }));
+    }
+    togglePanel(navIdOrItem, item) {
+        const { navId, navItem } = this.resolvePanelArgs('togglePanel', navIdOrItem, item);
+        if (navItem.disabled) {
+            return;
+        }
+        this.openPanelKeys.update((state) => ({
+            ...state,
+            [navId]: state[navId] === navItem.key ? null : navItem.key,
+        }));
+    }
+    closePanel(id = DEFAULT_NAVIGATION_ID) {
+        const navId = this.persistence.normalizeId(id);
+        this.openPanelKeys.update((state) => ({ ...state, [navId]: null }));
+    }
+    dockbarGroups(items) {
+        return items.filter((item) => item.children.length > 0);
+    }
+    resolveDockbarGroup(id, items, mode, activeIds, activeUrl) {
+        const groups = this.dockbarGroups(items);
+        const panelKey = this.openPanelKeys()[this.persistence.normalizeId(id)] ?? null;
+        if (panelKey !== null) {
+            const explicit = groups.find((group) => group.key === panelKey);
+            if (explicit) {
+                return explicit;
+            }
+        }
+        if (mode !== 'sticky') {
+            return null;
+        }
+        return groups.find((group) => this.isItemActive(group, activeIds, activeUrl)) ?? null;
+    }
+    isDrawerOpen(id) {
+        return this.drawerOpenState()[this.persistence.normalizeId(id)] ?? false;
+    }
+    openDrawer(id) {
+        const navId = this.persistence.normalizeId(id);
+        this.drawerOpenState.update((state) => ({ ...state, [navId]: true }));
+    }
+    toggleDrawer(id) {
+        const navId = this.persistence.normalizeId(id);
+        this.drawerOpenState.update((state) => ({ ...state, [navId]: !(state[navId] ?? false) }));
+    }
+    closeDrawer(id) {
+        const navId = this.persistence.normalizeId(id);
+        this.drawerOpenState.update((state) => ({ ...state, [navId]: false }));
+    }
+    matchesActiveTree(item, match) {
+        return this.urlResolver.matches(item, match, this.routerLinkActiveOptions(item));
+    }
+    withoutKey(record, key) {
+        const next = { ...record };
+        delete next[key];
+        return next;
+    }
+    resolvePanelArgs(method, navIdOrItem, item) {
+        if (typeof navIdOrItem === 'string') {
+            if (item === undefined) {
+                throw new Error(`[Navigation] ${method}(navId, item) membutuhkan item navigasi sebagai argumen kedua.`);
+            }
+            return {
+                navId: this.persistence.normalizeId(navIdOrItem),
+                navItem: item,
+            };
+        }
+        return { navId: DEFAULT_NAVIGATION_ID, navItem: navIdOrItem };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: NavigationService, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.4", ngImport: i0, type: NavigationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: NavigationService, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
 
 /**
  * Generated bundle index. Do not edit.
- */
+ */
+
+export { NavigationService };