@flower-city-online/itinerary-lib 0.0.6 → 0.0.9

package/esm2022/lib/itinerary-app/_services/custom-dropdown-menu.service.mjs

@@ -0,0 +1,241 @@
+import { Injectable } from '@angular/core';
+import { ICONS } from '../_constants/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./modal.service";
+import * as i3 from "@ngx-translate/core";
+export class CustomDropdownMenuService {
+    router;
+    modalService;
+    translateService;
+    cssClasses = ['custom-modal-class'];
+    ICONS = ICONS;
+    itemList = [
+        {
+            title: 'EDIT_ITINERARY',
+            iconUrl: ICONS['edit'],
+        },
+        {
+            title: 'ARCHIVE',
+            iconUrl: ICONS['archiveWhite'],
+        },
+        {
+            title: 'UNPUBLISH',
+            iconUrl: '',
+        },
+        {
+            title: 'ASSIGN_TO_CLIENT',
+            iconUrl: ICONS['headphone'],
+        },
+        {
+            title: 'ADD_TO_FAVORITES',
+            iconUrl: ICONS['heartWhite'],
+        },
+        {
+            title: 'REMOVE_FROM_FAVORITES',
+            iconUrl: ICONS['heartFillRed'],
+        },
+        {
+            title: 'SHARE_ITINERARY',
+            iconUrl: ICONS['share'],
+        },
+        {
+            title: 'BRANCH_THE_ITINERARY',
+            iconUrl: ICONS['branch'],
+        },
+        {
+            title: 'REPORT',
+            iconUrl: ICONS['report'],
+            command: () => {
+                this.openReportModal();
+            },
+        },
+        {
+            title: 'RESTORE_ITINERARY',
+            iconUrl: ICONS['restore'],
+        },
+        {
+            title: 'DELETE_FOREVER',
+            iconUrl: ICONS['deleteCross'],
+            command: () => {
+                this.openModal();
+            },
+        },
+        {
+            title: 'EDIT_COMMENT',
+            iconUrl: ICONS['edit'],
+            command: () => { },
+        },
+        {
+            title: 'REMOVE_FEATURE',
+            iconUrl: ICONS['removeFeature'],
+        },
+        {
+            title: 'DELETE_COMMENT',
+            iconUrl: ICONS['deleteCross'],
+        },
+        {
+            title: 'Details',
+            iconUrl: ICONS['userDetail'],
+        },
+        {
+            title: 'Remove',
+            iconUrl: ICONS['binWhite'],
+        },
+    ];
+    pageList = [
+        {
+            pageName: 'itineraries',
+            itemList: [
+                {
+                    title: 'ASSIGN_TO_CLIENT',
+                },
+                {
+                    title: 'ADD_TO_FAVORITES',
+                },
+                {
+                    title: 'SHARE_ITINERARY',
+                },
+                {
+                    title: 'BRANCH_THE_ITINERARY',
+                },
+                {
+                    title: 'REPORT',
+                    command: () => {
+                        this.openReportModal();
+                    },
+                },
+            ],
+        },
+        {
+            pageName: 'builder',
+            itemList: [
+                {
+                    title: 'EDIT_ITINERARY',
+                },
+                {
+                    title: 'UNPUBLISH',
+                },
+                {
+                    title: 'ARCHIVE',
+                },
+                {
+                    title: 'ADD_TO_FAVORITES',
+                },
+                {
+                    title: 'SHARE_ITINERARY',
+                },
+            ],
+        },
+        {
+            pageName: 'archives',
+            itemList: [
+                {
+                    title: 'RESTORE_ITINERARY',
+                },
+                {
+                    title: 'DELETE_FOREVER',
+                },
+            ],
+        },
+        {
+            pageName: 'favourite',
+            itemList: [
+                {
+                    title: 'REMOVE_FROM_FAVORITES',
+                },
+                {
+                    title: 'SHARE_ITINERARY',
+                },
+                {
+                    title: 'REPORT',
+                },
+            ],
+        },
+        {
+            pageName: 'stories',
+            itemList: [
+                {
+                    title: 'EDIT_COMMENT',
+                },
+                {
+                    title: 'REMOVE_FEATURE',
+                },
+                {
+                    title: 'DELETE_COMMENT',
+                },
+                {
+                    title: 'REPORT',
+                },
+            ],
+        },
+        {
+            pageName: 'comment-replies',
+            itemList: [
+                {
+                    title: 'REMOVE_FEATURE',
+                },
+                {
+                    title: 'DELETE_COMMENT',
+                },
+                {
+                    title: 'REPORT',
+                },
+            ],
+        },
+        {
+            pageName: 'create-itinerary-user-search',
+            itemList: [
+                {
+                    title: 'Details',
+                },
+                {
+                    title: 'Remove',
+                },
+            ],
+        },
+    ];
+    constructor(router, modalService, translateService) {
+        this.router = router;
+        this.modalService = modalService;
+        this.translateService = translateService;
+    }
+    getMenuList(pageName) {
+        // Find the pageList entry with matching pageName
+        const page = this.pageList.find((page) => page.pageName === pageName);
+        if (!page) {
+            return []; // Return an empty array if pageName is not found
+        }
+        // Filter the itemList to include only items whose titles are in page.itemList
+        const filteredList = this.itemList.filter((item) => page.itemList.some((pageItem) => pageItem.title === item.title));
+        filteredList.forEach((item) => {
+            item.title = item.title
+                ? this.translateService.instant(item.title)
+                : item.title;
+        });
+        page.itemList.forEach((item) => {
+            item.title = this.translateService.instant(item.title);
+        });
+        return filteredList;
+    }
+    openModal() {
+        this.modalService.toggleModal = !this.modalService.toggleModal;
+    }
+    openReportModal() {
+        this.modalService.toggleModal = !this.modalService.toggleModal;
+    }
+    navigateToRoute(path) {
+        this.router.navigate([path], {
+            queryParams: { mode: 'edit' },
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CustomDropdownMenuService, deps: [{ token: i1.Router }, { token: i2.ModalService }, { token: i3.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CustomDropdownMenuService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CustomDropdownMenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.ModalService }, { type: i3.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-dropdown-menu.service.js","sourceRoot":"","sources":["../../../../../../projects/itinerary-lib/src/lib/itinerary-app/_services/custom-dropdown-menu.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { LibMenuItem } from 'nextsapien-component-lib';\r\nimport { ModalService } from './modal.service'; \r\nimport { Iicon } from '../_interface/icon';\r\nimport { ICONS } from '../_constants/constants';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class CustomDropdownMenuService {\r\n  cssClasses = ['custom-modal-class'];\r\n  ICONS: Iicon = ICONS;\r\n  itemList: LibMenuItem[] = [\r\n    {\r\n      title: 'EDIT_ITINERARY',\r\n      iconUrl: ICONS['edit'],\r\n    },\r\n    {\r\n      title: 'ARCHIVE',\r\n      iconUrl: ICONS['archiveWhite'],\r\n    },\r\n    {\r\n      title: 'UNPUBLISH',\r\n      iconUrl: '',\r\n    },\r\n    {\r\n      title: 'ASSIGN_TO_CLIENT',\r\n      iconUrl: ICONS['headphone'],\r\n    },\r\n    {\r\n      title: 'ADD_TO_FAVORITES',\r\n      iconUrl: ICONS['heartWhite'],\r\n    },\r\n    {\r\n      title: 'REMOVE_FROM_FAVORITES',\r\n      iconUrl: ICONS['heartFillRed'],\r\n    },\r\n    {\r\n      title: 'SHARE_ITINERARY',\r\n      iconUrl: ICONS['share'],\r\n    },\r\n    {\r\n      title: 'BRANCH_THE_ITINERARY',\r\n      iconUrl: ICONS['branch'],\r\n    },\r\n    {\r\n      title: 'REPORT',\r\n      iconUrl: ICONS['report'],\r\n      command: () => {\r\n        this.openReportModal();\r\n      },\r\n    },\r\n    {\r\n      title: 'RESTORE_ITINERARY',\r\n      iconUrl: ICONS['restore'],\r\n    },\r\n    {\r\n      title: 'DELETE_FOREVER',\r\n      iconUrl: ICONS['deleteCross'],\r\n      command: () => {\r\n        this.openModal();\r\n      },\r\n    },\r\n    {\r\n      title: 'EDIT_COMMENT',\r\n      iconUrl: ICONS['edit'],\r\n      command: () => {},\r\n    },\r\n    {\r\n      title: 'REMOVE_FEATURE',\r\n      iconUrl: ICONS['removeFeature'],\r\n    },\r\n    {\r\n      title: 'DELETE_COMMENT',\r\n      iconUrl: ICONS['deleteCross'],\r\n    },\r\n    {\r\n      title: 'Details',\r\n      iconUrl: ICONS['userDetail'],\r\n    },\r\n    {\r\n      title: 'Remove',\r\n      iconUrl: ICONS['binWhite'],\r\n    },\r\n  ];\r\n\r\n  pageList = [\r\n    {\r\n      pageName: 'itineraries',\r\n      itemList: [\r\n        {\r\n          title: 'ASSIGN_TO_CLIENT',\r\n        },\r\n        {\r\n          title: 'ADD_TO_FAVORITES',\r\n        },\r\n        {\r\n          title: 'SHARE_ITINERARY',\r\n        },\r\n        {\r\n          title: 'BRANCH_THE_ITINERARY',\r\n        },\r\n        {\r\n          title: 'REPORT',\r\n          command: () => {\r\n            this.openReportModal();\r\n          },\r\n        },\r\n      ],\r\n    },\r\n    {\r\n      pageName: 'builder',\r\n      itemList: [\r\n        {\r\n          title: 'EDIT_ITINERARY',\r\n        },\r\n        {\r\n          title: 'UNPUBLISH',\r\n        },\r\n        {\r\n          title: 'ARCHIVE',\r\n        },\r\n        {\r\n          title: 'ADD_TO_FAVORITES',\r\n        },\r\n        {\r\n          title: 'SHARE_ITINERARY',\r\n        },\r\n      ],\r\n    },\r\n    {\r\n      pageName: 'archives',\r\n      itemList: [\r\n        {\r\n          title: 'RESTORE_ITINERARY',\r\n        },\r\n        {\r\n          title: 'DELETE_FOREVER',\r\n        },\r\n      ],\r\n    },\r\n    {\r\n      pageName: 'favourite',\r\n      itemList: [\r\n        {\r\n          title: 'REMOVE_FROM_FAVORITES',\r\n        },\r\n        {\r\n          title: 'SHARE_ITINERARY',\r\n        },\r\n        {\r\n          title: 'REPORT',\r\n        },\r\n      ],\r\n    },\r\n    {\r\n      pageName: 'stories',\r\n      itemList: [\r\n        {\r\n          title: 'EDIT_COMMENT',\r\n        },\r\n        {\r\n          title: 'REMOVE_FEATURE',\r\n        },\r\n        {\r\n          title: 'DELETE_COMMENT',\r\n        },\r\n        {\r\n          title: 'REPORT',\r\n        },\r\n      ],\r\n    },\r\n    {\r\n      pageName: 'comment-replies',\r\n      itemList: [\r\n        {\r\n          title: 'REMOVE_FEATURE',\r\n        },\r\n        {\r\n          title: 'DELETE_COMMENT',\r\n        },\r\n        {\r\n          title: 'REPORT',\r\n        },\r\n      ],\r\n    },\r\n    {\r\n      pageName: 'create-itinerary-user-search',\r\n      itemList: [\r\n        {\r\n          title: 'Details',\r\n        },\r\n        {\r\n          title: 'Remove',\r\n        },\r\n      ],\r\n    },\r\n  ];\r\n\r\n  constructor(\r\n    public router: Router,\r\n    public modalService: ModalService,\r\n    public translateService: TranslateService,\r\n  ) {}\r\n\r\n  getMenuList(pageName: string): LibMenuItem[] {\r\n    // Find the pageList entry with matching pageName\r\n    const page = this.pageList.find((page) => page.pageName === pageName);\r\n    if (!page) {\r\n      return []; // Return an empty array if pageName is not found\r\n    }\r\n\r\n    // Filter the itemList to include only items whose titles are in page.itemList\r\n    const filteredList = this.itemList.filter((item) =>\r\n      page.itemList.some((pageItem) => pageItem.title === item.title),\r\n    );\r\n\r\n    filteredList.forEach((item) => {\r\n      item.title = item.title\r\n        ? this.translateService.instant(item.title)\r\n        : item.title;\r\n    });\r\n    page.itemList.forEach((item) => {\r\n      item.title = this.translateService.instant(item.title);\r\n    });\r\n    return filteredList;\r\n  }\r\n\r\n  openModal(): void {\r\n    this.modalService.toggleModal = !this.modalService.toggleModal;\r\n  }\r\n  openReportModal(): void {\r\n    this.modalService.toggleModal = !this.modalService.toggleModal;\r\n  }\r\n  navigateToRoute(path: string): void {\r\n    this.router.navigate([path], {\r\n      queryParams: { mode: 'edit' },\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/itinerary-app/_services/itinerary.service.mjs

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ItineraryService {
+    http;
+    url = 'itinerary';
+    constructor(http) {
+        this.http = http;
+    }
+    getMapData() {
+        return this.http.get('/assets/itinerary-map-data.json');
+    }
+    loadAll() {
+        const raw = localStorage.getItem(this.url);
+        return raw ? JSON.parse(raw) : [];
+    }
+    saveAll(list) {
+        localStorage.setItem(this.url, JSON.stringify(list));
+    }
+    create(it) {
+        const list = this.loadAll();
+        list.push(it);
+        this.saveAll(list);
+    }
+    getByName(name) {
+        return this.loadAll().find((i) => i.name === name);
+    }
+    getAll() {
+        return this.loadAll();
+    }
+    getById(id) {
+        const all = this.getAll();
+        return all.find((x) => x.id === id);
+    }
+    getDraftByUserId(_id = '') {
+        const all = this.getAll();
+        return all.filter((x) => x.isCompleted === false);
+    }
+    update(updated) {
+        const list = this.loadAll();
+        const idx = list.findIndex((i) => i.name === updated.name);
+        if (idx === -1) {
+            throw new Error(`Itinerary named "${updated.name}" not found`);
+        }
+        list[idx] = updated;
+        this.saveAll(list);
+    }
+    delete(name) {
+        const list = this.loadAll().filter((i) => i.name !== name);
+        this.saveAll(list);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/itinerary-app/_services/location.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export class LocationService {
+    getCurrentLocation() {
+        return new Observable((observer) => {
+            if (navigator.geolocation) {
+                navigator.geolocation.getCurrentPosition((position) => {
+                    observer.next({
+                        lat: position.coords.latitude,
+                        long: position.coords.longitude,
+                    });
+                    observer.complete();
+                }, (error) => {
+                    observer.error(`Geolocation error: ${error.message}`);
+                });
+            }
+            else {
+                observer.error('Geolocation is not supported by this browser.');
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYXRpb24uc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2l0aW5lcmFyeS1saWIvc3JjL2xpYi9pdGluZXJhcnktYXBwL19zZXJ2aWNlcy9sb2NhdGlvbi5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFLbEMsTUFBTSxPQUFPLGVBQWU7SUFDMUIsa0JBQWtCO1FBQ2hCLE9BQU8sSUFBSSxVQUFVLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRTtZQUNqQyxJQUFJLFNBQVMsQ0FBQyxXQUFXLEVBQUU7Z0JBQ3pCLFNBQVMsQ0FBQyxXQUFXLENBQUMsa0JBQWtCLENBQ3RDLENBQUMsUUFBUSxFQUFFLEVBQUU7b0JBQ1gsUUFBUSxDQUFDLElBQUksQ0FBQzt3QkFDWixHQUFHLEVBQUUsUUFBUSxDQUFDLE1BQU0sQ0FBQyxRQUFRO3dCQUM3QixJQUFJLEVBQUUsUUFBUSxDQUFDLE1BQU0sQ0FBQyxTQUFTO3FCQUNoQyxDQUFDLENBQUM7b0JBQ0gsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUN0QixDQUFDLEVBQ0QsQ0FBQyxLQUFLLEVBQUUsRUFBRTtvQkFDUixRQUFRLENBQUMsS0FBSyxDQUFDLHNCQUFzQixLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztnQkFDeEQsQ0FBQyxDQUNGLENBQUM7YUFDSDtpQkFBTTtnQkFDTCxRQUFRLENBQUMsS0FBSyxDQUFDLCtDQUErQyxDQUFDLENBQUM7YUFDakU7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7d0dBcEJVLGVBQWU7NEdBQWYsZUFBZSxjQUZkLE1BQU07OzRGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTG9jYXRpb25TZXJ2aWNlIHtcclxuICBnZXRDdXJyZW50TG9jYXRpb24oKTogT2JzZXJ2YWJsZTx7IGxhdDogbnVtYmVyOyBsb25nOiBudW1iZXIgfT4ge1xyXG4gICAgcmV0dXJuIG5ldyBPYnNlcnZhYmxlKChvYnNlcnZlcikgPT4ge1xyXG4gICAgICBpZiAobmF2aWdhdG9yLmdlb2xvY2F0aW9uKSB7XHJcbiAgICAgICAgbmF2aWdhdG9yLmdlb2xvY2F0aW9uLmdldEN1cnJlbnRQb3NpdGlvbihcclxuICAgICAgICAgIChwb3NpdGlvbikgPT4ge1xyXG4gICAgICAgICAgICBvYnNlcnZlci5uZXh0KHtcclxuICAgICAgICAgICAgICBsYXQ6IHBvc2l0aW9uLmNvb3Jkcy5sYXRpdHVkZSxcclxuICAgICAgICAgICAgICBsb25nOiBwb3NpdGlvbi5jb29yZHMubG9uZ2l0dWRlLFxyXG4gICAgICAgICAgICB9KTtcclxuICAgICAgICAgICAgb2JzZXJ2ZXIuY29tcGxldGUoKTtcclxuICAgICAgICAgIH0sXHJcbiAgICAgICAgICAoZXJyb3IpID0+IHtcclxuICAgICAgICAgICAgb2JzZXJ2ZXIuZXJyb3IoYEdlb2xvY2F0aW9uIGVycm9yOiAke2Vycm9yLm1lc3NhZ2V9YCk7XHJcbiAgICAgICAgICB9LFxyXG4gICAgICAgICk7XHJcbiAgICAgIH0gZWxzZSB7XHJcbiAgICAgICAgb2JzZXJ2ZXIuZXJyb3IoJ0dlb2xvY2F0aW9uIGlzIG5vdCBzdXBwb3J0ZWQgYnkgdGhpcyBicm93c2VyLicpO1xyXG4gICAgICB9XHJcbiAgICB9KTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/{_services → itinerary-app/_services}/modal.service.mjs

@@ -14,4 +14,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2l0aW5lcmFyeS1saWIvc3JjL2xpYi9fc2VydmljZXMvbW9kYWwuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8sWUFBWTtJQUNoQixXQUFXLEdBQVksS0FBSyxDQUFDO0lBQzdCLGlCQUFpQixHQUFZLEtBQUssQ0FBQztJQUNuQyxrQkFBa0IsR0FBWSxLQUFLLENBQUM7SUFFM0MsZ0JBQWdCLENBQUM7d0dBTE4sWUFBWTs0R0FBWixZQUFZLGNBRlgsTUFBTTs7NEZBRVAsWUFBWTtrQkFIeEIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTW9kYWxTZXJ2aWNlIHtcclxuICBwdWJsaWMgdG9nZ2xlTW9kYWw6IGJvb2xlYW4gPSBmYWxzZTtcclxuICBwdWJsaWMgYm90dG9tVG9nZ2xlTW9kYWw6IGJvb2xlYW4gPSBmYWxzZTtcclxuICBwdWJsaWMgdG9nZ2xlR2xvYmFsU2VhcmNoOiBib29sZWFuID0gZmFsc2U7XHJcblxyXG4gIGNvbnN0cnVjdG9yKCkgeyB9XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2l0aW5lcmFyeS1saWIvc3JjL2xpYi9pdGluZXJhcnktYXBwL19zZXJ2aWNlcy9tb2RhbC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxZQUFZO0lBQ2hCLFdBQVcsR0FBWSxLQUFLLENBQUM7SUFDN0IsaUJBQWlCLEdBQVksS0FBSyxDQUFDO0lBQ25DLGtCQUFrQixHQUFZLEtBQUssQ0FBQztJQUUzQyxnQkFBZ0IsQ0FBQzt3R0FMTixZQUFZOzRHQUFaLFlBQVksY0FGWCxNQUFNOzs0RkFFUCxZQUFZO2tCQUh4QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCcsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBNb2RhbFNlcnZpY2Uge1xyXG4gIHB1YmxpYyB0b2dnbGVNb2RhbDogYm9vbGVhbiA9IGZhbHNlO1xyXG4gIHB1YmxpYyBib3R0b21Ub2dnbGVNb2RhbDogYm9vbGVhbiA9IGZhbHNlO1xyXG4gIHB1YmxpYyB0b2dnbGVHbG9iYWxTZWFyY2g6IGJvb2xlYW4gPSBmYWxzZTtcclxuXHJcbiAgY29uc3RydWN0b3IoKSB7IH1cclxufVxyXG4iXX0=

package/esm2022/lib/itinerary-app/_services/shadow-root-handler.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ShadowRootHandlerService {
+    accessShadowRoot(targetNode, componentName, callback) {
+        // Query the custom element
+        const element = targetNode.querySelector(componentName);
+        if (element) {
+            // Create a MutationObserver to monitor changes
+            const observer = new MutationObserver((mutationsList) => {
+                for (const mutation of mutationsList) {
+                    if (mutation.type === 'childList' || mutation.type === 'attributes') {
+                        callback();
+                    }
+                }
+            });
+            // Observe the element for changes
+            observer.observe(element, {
+                childList: true,
+                subtree: true,
+                attributes: true,
+            });
+            // Apply callback when the component is initialized
+            callback();
+            // observer.disconnect();
+        }
+        else {
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShadowRootHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShadowRootHandlerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShadowRootHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/itinerary-app/itinerary-lib-routing.module.mjs

@@ -0,0 +1,50 @@
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { ArchivesModule } from './modules/archives/archives.module';
+import { DashboardModule } from './modules/dashboard/dashboard.module';
+import { ItinerariesModule } from './modules/itineraries/itineraries.module';
+import { PathwayModule } from './modules/pathway/pathway.module';
+import { SearchModule } from './modules/search/search.module';
+import { UserModule } from './modules/user/user.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const routes = [
+    { path: '', redirectTo: 'itineraries', pathMatch: 'full' },
+    {
+        path: 'itineraries',
+        loadChildren: () => ItinerariesModule
+    },
+    {
+        path: 'search',
+        loadChildren: () => SearchModule
+    },
+    {
+        path: 'archives',
+        loadChildren: () => ArchivesModule
+    },
+    {
+        path: 'dashboard',
+        loadChildren: () => DashboardModule,
+    },
+    {
+        path: 'pathway',
+        loadChildren: () => PathwayModule
+    },
+    {
+        path: 'user',
+        loadChildren: () => UserModule
+    },
+];
+export class ItineraryLibRoutingModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryLibRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: ItineraryLibRoutingModule, imports: [i1.RouterModule], exports: [RouterModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryLibRoutingModule, imports: [RouterModule.forChild(routes), RouterModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryLibRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [RouterModule.forChild(routes)],
+                    exports: [RouterModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/itinerary-app/itinerary-lib.component.mjs

@@ -0,0 +1,77 @@
+import { Breakpoints } from '@angular/cdk/layout';
+import { Component, HostListener, inject, ViewChild, ViewContainerRef } from '@angular/core';
+import { PopupModalService } from 'nextsapien-component-lib';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/layout";
+import * as i2 from "@angular/common";
+import * as i3 from "./_services/bottom-navigation.service";
+import * as i4 from "@angular/router";
+export class ItineraryLibComponent {
+    breakpointObserver;
+    renderer;
+    el;
+    location;
+    navService;
+    isSmallScreen = false;
+    breakpointSubscription;
+    dynamicModal;
+    popupModalService = inject(PopupModalService);
+    constructor(breakpointObserver, renderer, el, location, navService) {
+        this.breakpointObserver = breakpointObserver;
+        this.renderer = renderer;
+        this.el = el;
+        this.location = location;
+        this.navService = navService;
+    }
+    ngOnInit() {
+        this.handleScreenSizeChange();
+    }
+    ngAfterViewInit() {
+        this.popupModalService.setRootViewContainerRef(this.dynamicModal);
+    }
+    //use to change application ui and behaviour based on screen size
+    handleScreenSizeChange() {
+        this.checkWindowWidth();
+        this.breakpointSubscription = this.breakpointObserver
+            .observe([Breakpoints.Small, Breakpoints.XSmall])
+            .subscribe((state) => {
+            this.isSmallScreen = state.matches;
+            if (this.isSmallScreen) {
+                this.renderer.removeClass(document.body, 'customBody');
+            }
+            else {
+                this.renderer.addClass(document.body, 'customBody');
+            }
+        });
+    }
+    onResize(_event) {
+        this.checkWindowWidth();
+    }
+    checkWindowWidth() {
+        const width = window.innerWidth;
+        if (width <= 960) {
+            if (this.location.path().includes('dashboard')) {
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.breakpointSubscription.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryLibComponent, deps: [{ token: i1.BreakpointObserver }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i2.Location }, { token: i3.BottomNavigationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ItineraryLibComponent, selector: "lib-itinerary-lib", host: { listeners: { "window:resize": "onResize($event)" } }, viewQueries: [{ propertyName: "dynamicModal", first: true, predicate: ["dynamicModal"], descendants: true, read: ViewContainerRef }], ngImport: i0, template: `
+    <router-outlet></router-outlet> <ng-container #dynamicModal></ng-container>
+  `, isInline: true, styles: [""], dependencies: [{ kind: "directive", type: i4.RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ItineraryLibComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-itinerary-lib', template: `
+    <router-outlet></router-outlet> <ng-container #dynamicModal></ng-container>
+  ` }]
+        }], ctorParameters: () => [{ type: i1.BreakpointObserver }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i2.Location }, { type: i3.BottomNavigationService }], propDecorators: { dynamicModal: [{
+                type: ViewChild,
+                args: ['dynamicModal', { read: ViewContainerRef }]
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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