@haloduck/core 2.0.1 → 2.0.2

package/fesm2022/haloduck-core.mjs

@@ -0,0 +1,881 @@
+import { from, switchMap, of, distinctUntilChanged, map, catchError, delay, withLatestFrom, tap, forkJoin } from 'rxjs';
+import { fetchAuthSession } from 'aws-amplify/auth';
+import * as i0 from '@angular/core';
+import { inject, isDevMode, Pipe, Injectable, InjectionToken, Inject } from '@angular/core';
+import { createFeatureSelector, createSelector, Store, createAction, props, createReducer, on } from '@ngrx/store';
+import { HttpClient } from '@angular/common/http';
+import { map as map$1, catchError as catchError$1, withLatestFrom as withLatestFrom$1, mergeMap, finalize } from 'rxjs/operators';
+import { ComponentStore } from '@ngrx/component-store';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+
+const authGuard = (route, state) => {
+    return from(fetchAuthSession()).pipe(switchMap((session) => {
+        if (session.tokens?.idToken) {
+            return of(true);
+        }
+        window.location.href = '/authenticate';
+        return of(false);
+    }));
+};
+
+// deprecated
+const dummyMemberIdInterceptor = (req, next) => {
+    const dummyMemberId = localStorage.getItem('dummyMemberId');
+    if (req.url.startsWith('http://localhost')) {
+        if (dummyMemberId) {
+            const clonedRequest = req.clone({
+                setHeaders: {
+                    'X-Dummy-Member-Id': dummyMemberId || '',
+                },
+            });
+            return next(clonedRequest);
+        }
+    }
+    return next(req);
+};
+
+var GlobalSelectors;
+(function (GlobalSelectors) {
+    GlobalSelectors.selectGlobalState = createFeatureSelector('global');
+    GlobalSelectors.isInitiated = createSelector(GlobalSelectors.selectGlobalState, (state) => state.initiated);
+    GlobalSelectors.selectIsAuthenticated = createSelector(GlobalSelectors.selectGlobalState, (state) => state.isAuthenticated);
+    GlobalSelectors.selectProfile = createSelector(GlobalSelectors.selectGlobalState, (state) => state.profile);
+    GlobalSelectors.selectIsLoading = createSelector(GlobalSelectors.selectGlobalState, (state) => state.loadingReference > 0);
+    GlobalSelectors.selectAcl = createSelector(GlobalSelectors.selectGlobalState, (state) => state.acl);
+    GlobalSelectors.selectListMenuItem = createSelector(GlobalSelectors.selectGlobalState, (state) => state.listMenuItem);
+    GlobalSelectors.selectIsSideMenuOpen = createSelector(GlobalSelectors.selectGlobalState, (state) => state.isSideMenuOpen);
+    GlobalSelectors.selectLanguage = createSelector(GlobalSelectors.selectGlobalState, (state) => state.language);
+    GlobalSelectors.canActivate = (resource, action, shouldStripTag) => createSelector(GlobalSelectors.selectAcl, (acl) => {
+        const allowedActions = [];
+        switch (action) {
+            case 'delete':
+                allowedActions.push('delete');
+                break;
+            case 'create':
+                allowedActions.push('delete');
+                allowedActions.push('create');
+                break;
+            case 'update':
+                allowedActions.push('delete');
+                allowedActions.push('create');
+                allowedActions.push('update');
+                break;
+            case 'read':
+                allowedActions.push('delete');
+                allowedActions.push('create');
+                allowedActions.push('update');
+                allowedActions.push('read');
+        }
+        const result = Object.keys(acl).some((aclKey) => {
+            return ['delete', 'create', 'update', 'read'].some((_action) => {
+                if (undefined === acl[aclKey][_action]) {
+                    return false;
+                }
+                let [_resource, _conditionsRaw] = resource.split(':');
+                const _conditions = _conditionsRaw ? _conditionsRaw.split('|') : [];
+                _resource =
+                    shouldStripTag && _resource.includes('/')
+                        ? _resource.split('/')[0]
+                        : _resource;
+                const _resourceAclArray = acl[aclKey][_action];
+                return _resourceAclArray.some((_resourceAclRaw) => {
+                    const [_resourceAcl, _conditionsAclRaw] = _resourceAclRaw.split(':');
+                    const _conditionsAcl = _conditionsAclRaw
+                        ? _conditionsAclRaw.split('|')
+                        : [];
+                    if (_resourceAcl === '*') {
+                        return true;
+                    }
+                    if (_resource === _resourceAcl &&
+                        allowedActions.includes(_action) &&
+                        (_conditions.length === 0 ||
+                            _conditionsAcl.some((_condition) => _conditions.includes(_condition)))) {
+                        return true;
+                    }
+                    return false;
+                });
+            });
+        });
+        return result;
+    });
+    GlobalSelectors.selectCurrentGroupId = createSelector(GlobalSelectors.selectGlobalState, (state) => state.currentGroup?.id);
+    GlobalSelectors.selectCurrentGroup = createSelector(GlobalSelectors.selectGlobalState, (state) => state.currentGroup);
+})(GlobalSelectors || (GlobalSelectors = {}));
+
+// deprecated
+const groupIdInterceptor = (req, next) => {
+    const store = inject((Store));
+    const groupId$ = store.select(GlobalSelectors.selectCurrentGroupId);
+    if (req.url.endsWith('/member/me'))
+        return next(req);
+    if (req.url.endsWith('/menu'))
+        return next(req);
+    if (req.url.endsWith('/acl'))
+        return next(req);
+    if (req.url.startsWith('https://api') ||
+        req.url.startsWith('http://localhost')) {
+        return groupId$.pipe(switchMap((groupId) => {
+            if (groupId) {
+                const clonedRequest = req.clone({
+                    setHeaders: {
+                        'X-Group-Id': groupId || '',
+                    },
+                });
+                return next(clonedRequest);
+            }
+            return next(req);
+        }));
+    }
+    return next(req);
+};
+
+const idTokenInterceptor = (req, next) => {
+    if (req.url.endsWith('/oauth2/token'))
+        return next(req);
+    if (req.url.startsWith('https://api')) {
+        return from(fetchAuthSession()).pipe(switchMap((session) => {
+            if (session.tokens?.idToken) {
+                const clonedRequest = req.clone({
+                    setHeaders: {
+                        Authorization: `Bearer ${session.tokens.idToken}`,
+                    },
+                });
+                return next(clonedRequest);
+            }
+            return next(req);
+        }));
+    }
+    else if (req.url.startsWith('https://auth') || req.url.startsWith('https://eleven-auth')) {
+        return from(fetchAuthSession()).pipe(switchMap((session) => {
+            if (session.tokens?.accessToken) {
+                const clonedRequest = req.clone({
+                    setHeaders: {
+                        Authorization: `Bearer ${session.tokens.accessToken}`,
+                    },
+                });
+                return next(clonedRequest);
+            }
+            return next(req);
+        }));
+    }
+    return next(req);
+};
+
+var SearchParams;
+(function (SearchParams) {
+    SearchParams.SortDirectionAsc = 'asc';
+    SearchParams.SortDirectionDesc = 'desc';
+    // export interface OrderAndPage{
+    //     size: number;
+    //     sort: Order[];
+    //     searchAfter?: any[];
+    // }
+})(SearchParams || (SearchParams = {}));
+
+function responseHandler(response) {
+    if (!response) {
+        errorHandler({
+            error: 'empty response',
+            message: 'empty response',
+        });
+    }
+    if (response.error != '00') {
+        errorHandler({
+            error: response.error,
+            message: response.message,
+        });
+    }
+    return response;
+}
+function errorHandler(err) {
+    isDevMode() && console.error('API Error: ', err);
+    throw err;
+}
+
+class DisplayNamePipe {
+    transform(member) {
+        if (!member)
+            return '';
+        return (member.nickname?.trim() ||
+            (member.firstName || '') + ' ' + (member.lastName || ''));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: DisplayNamePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.1.4", ngImport: i0, type: DisplayNamePipe, isStandalone: true, name: "displayName" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: DisplayNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'displayName',
+                }]
+        }] });
+
+var GlobalActions;
+(function (GlobalActions) {
+    GlobalActions.markInitiated = createAction('[Global] Mark Initiated', props());
+    GlobalActions.clearAuthentication = createAction('[Global] Clear Authentication');
+    GlobalActions.setAuthenticated = createAction('[Global] Set Authenticated', props());
+    GlobalActions.setProfile = createAction('[Global] Set Profile', props());
+    GlobalActions.increaseLoadingReference = createAction('[Global] Increase Loading Reference');
+    GlobalActions.decreaseLoadingReference = createAction('[Global] Decrease Loading Reference');
+    GlobalActions.setAcl = createAction('[Global] Set Acl', props());
+    GlobalActions.setListMenuItem = createAction('[Global] Set List Menu Item', props());
+    GlobalActions.toggleSideMenu = createAction('[Global] Toggle Side Menu');
+    GlobalActions.closeSideMenu = createAction('[Global] Close Side Menu');
+    GlobalActions.setLanguage = createAction('[Global] Set Language', props());
+    GlobalActions.setCurrentGroup = createAction('[Global] Set Current Group', props());
+})(GlobalActions || (GlobalActions = {}));
+
+class AuthService {
+    globalStore = inject((Store));
+    canActivate(resource, action, shouldStripTag) {
+        return this.globalStore
+            .select(GlobalSelectors.canActivate(resource, action, shouldStripTag))
+            .pipe(distinctUntilChanged());
+    }
+    getProfile() {
+        return this.globalStore.select(GlobalSelectors.selectProfile);
+    }
+    setProfile(profile) {
+        return this.globalStore.dispatch(GlobalActions.setProfile({ profile }));
+    }
+    isAuthenticated() {
+        return this.globalStore
+            .select(GlobalSelectors.selectIsAuthenticated)
+            .pipe(distinctUntilChanged());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const defaultLanguage = { id: 'en', value: 'English' };
+const supportedLanguages = [
+    defaultLanguage,
+    { id: 'ko', value: '한국어' },
+];
+const HALODUCK_CORE_CONFIG = new InjectionToken('HALODUCK_CORE_CONFIG', {
+    providedIn: 'root',
+    factory: () => ({
+        stage: 'local',
+        appName: 'please-register-app-name-via-provideHaloduckCoreConfig',
+        defaultLanguage: defaultLanguage.id,
+        dateFormat: {
+            long: 'yyyy-MM-dd',
+            short: 'yyMMdd',
+        },
+        apiUrl: 'https://please-register-via-provideHaloduckCoreConfig.com',
+        cdnUrl: 'https://please-register-via-provideHaloduckCoreConfig.com',
+        map: {
+            mapId: 'please-register-map-id-via-provideHaloduckCoreConfig',
+            googleApiKey: 'please-register-google-api-key-via-provideHaloduckCoreConfig',
+            defaultLngLat: {
+                lat: 37.575971,
+                lng: 126.976800,
+            },
+        },
+    }),
+});
+function provideHaloduckCoreConfig(config) {
+    return {
+        provide: HALODUCK_CORE_CONFIG,
+        useValue: config,
+    };
+}
+class CoreService {
+    config = inject(HALODUCK_CORE_CONFIG);
+    constructor() { }
+    getStage() {
+        return this.config.stage;
+    }
+    getAppName() {
+        return this.config.appName;
+    }
+    getDefaultLanguage() {
+        return this.config.defaultLanguage;
+    }
+    getApiUrl() {
+        return this.config.apiUrl;
+    }
+    getCdnUrl() {
+        return this.config.cdnUrl;
+    }
+    getDateFormatLong() {
+        return this.config.dateFormat.long;
+    }
+    getDateFormatShort() {
+        return this.config.dateFormat.short;
+    }
+    getGoogleApiKey() {
+        return this.config.map.googleApiKey;
+    }
+    getMapId() {
+        return this.config.map.mapId;
+    }
+    getDefaultLngLat() {
+        return this.config.map.defaultLngLat;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: CoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: CoreService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: CoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class BaseEntityApiService {
+    coreService = inject(CoreService);
+    http = inject(HttpClient);
+    apiUrl = this.coreService.getApiUrl();
+    createEntity(entity, parent) {
+        return this.http
+            .put(`${this.apiUrl}/${parent ? parent.name + '/' + parent.id + '/' : ''}${this.getEntityName()}`, entity)
+            .pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    getListEntity(searchParams, parent) {
+        const filter = JSON.stringify(searchParams.filter);
+        const sort = JSON.stringify(searchParams.sort);
+        const page = searchParams.page ? JSON.stringify(searchParams.page) : '';
+        return this.http
+            .get(`${this.apiUrl}/${parent ? parent.name + '/' + parent.id + '/' : ''}${this.getEntityName()}`, {
+            params: { filter, sort, page },
+        })
+            .pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    getEntityById(id) {
+        return this.http
+            .get(`${this.apiUrl}/${this.getEntityName()}/${id}`)
+            .pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    updateEntityById(id, entity) {
+        return this.http
+            .patch(`${this.apiUrl}/${this.getEntityName()}/${id}`, entity)
+            .pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    deleteEntityById(id) {
+        return this.http
+            .delete(`${this.apiUrl}/${this.getEntityName()}/${id}`)
+            .pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    getEntityName() {
+        throw new Error('Method not implemented.');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: BaseEntityApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: BaseEntityApiService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: BaseEntityApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CdnApiService {
+    coreService = inject(CoreService);
+    http = inject(HttpClient);
+    apiUrl = this.coreService.getApiUrl();
+    upload(file, keyPrefix) {
+        return this.getPresignedPutUrl(`${keyPrefix}/${file.name}`).pipe(switchMap((response) => {
+            const presignedUrl = response.data.url;
+            const key = response.data.key;
+            return this.uploadFile(presignedUrl, file).pipe(map(() => {
+                return key;
+            }), catchError((error) => {
+                console.error('Upload error:', error);
+                return errorHandler(error);
+            }));
+        }), catchError((error) => {
+            console.error('Error getting presigned URL:', error);
+            return errorHandler(error);
+        }));
+    }
+    getPresignedPutUrl(key) {
+        return this.http
+            .get(`${this.apiUrl}/tool/presignedPutUrl`, {
+            params: { key },
+        })
+            .pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    uploadFile(presignedUrl, file) {
+        return this.http
+            .put(presignedUrl, file, {
+            headers: { 'x-amz-tagging': 'expire1D=true' },
+        })
+            .pipe(catchError((error) => errorHandler(error)));
+    }
+    getPresignedGetUrl(key) {
+        return this.http
+            .get(`${this.apiUrl}/tool/presignedGetUrl`, {
+            params: { key },
+        })
+            .pipe(delay(10000), // Simulate a delay of 1 second
+        map((response) => responseHandler(response)), catchError((error) => errorHandler(error)), map((response) => response.data.url));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: CdnApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: CdnApiService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: CdnApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class GlobalApiService {
+    coreService = inject(CoreService);
+    http = inject(HttpClient);
+    apiUrl = this.coreService.getApiUrl();
+    getAcl() {
+        return this.http.get(`${this.apiUrl}/acl`).pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    getListMenuItem() {
+        return this.http
+            .get(`${this.apiUrl}/menu`)
+            .pipe(map((response) => responseHandler(response)), catchError((error) => errorHandler(error)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GlobalApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GlobalApiService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GlobalApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class GroupApiService extends BaseEntityApiService {
+    getEntityName() {
+        return 'group';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GroupApiService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GroupApiService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GroupApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class MemberApiService extends BaseEntityApiService {
+    getEntityName() {
+        return 'member';
+    }
+    getProfile() {
+        return this.http
+            .get(`${this.apiUrl}/${this.getEntityName()}/me`)
+            .pipe(map$1((response) => responseHandler(response)), catchError$1((error) => errorHandler(error)));
+    }
+    checkMemberByEmail(email) {
+        return this.http
+            .get(`${this.apiUrl}/${this.getEntityName()}/check/email/${email}`)
+            .pipe(map$1((response) => responseHandler(response)), catchError$1((error) => errorHandler(error)));
+    }
+    checkMemberByNickname(nickname) {
+        return this.http
+            .get(`${this.apiUrl}/${this.getEntityName()}/check/nickname/${nickname}`)
+            .pipe(map$1((response) => responseHandler(response)), catchError$1((error) => errorHandler(error)));
+    }
+    registration(member) {
+        return this.http
+            .put(`${this.apiUrl}/${this.getEntityName()}/registration`, member)
+            .pipe(map$1((response) => responseHandler(response)), catchError$1((error) => errorHandler(error)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: MemberApiService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: MemberApiService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: MemberApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const ITableStateStatusCreating = 'creating';
+const ITableStateStatusCreated = 'created';
+const ITableStateStatusFailedToCreate = 'failedToCreate';
+const ITableStateStatusUpdating = 'updating';
+const ITableStateStatusUpdated = 'updated';
+const ITableStateStatusFailedToUpdate = 'failedToUpdate';
+const ITableStateStatusDeleting = 'deleting';
+const ITableStateStatusDeleted = 'deleted';
+const ITableStateStatusFailedToDelete = 'failedToDelete';
+const ITableStateStatusLoading = 'loading';
+const ITableStateStatusLoaded = 'loaded';
+const ITableStateStatusFailedToLoad = 'failedToLoad';
+class TableStore extends ComponentStore {
+    initialState;
+    apiService;
+    // selectors
+    status$ = this.select((state) => state.status);
+    parent$ = this.select((state) => state.parent);
+    filter$ = this.select((state) => state.filter);
+    sort$ = this.select((state) => state.sort);
+    page$ = this.select((state) => state.page);
+    listEntity$ = this.select((state) => state.listEntity);
+    isLoading$ = this.select((state) => state.isLoading);
+    lastEvaluatedKey$ = this.select((state) => state.lastEvaluatedKey);
+    // effects
+    loadListEntity = this.effect((trigger$) => trigger$.pipe(withLatestFrom(this.listEntity$, this.filter$, this.sort$, this.page$, this.parent$), switchMap(([, listEntity, filter, sort, page, parent]) => {
+        this.updateStatus(ITableStateStatusLoading);
+        return this.apiService
+            .getListEntity({ filter, sort, page }, parent)
+            .pipe(tap((response) => {
+            this.patchState({
+                listEntity: [
+                    ...listEntity,
+                    ...(response.data ? response.data : []),
+                ],
+                lastEvaluatedKey: response.lastEvaluatedKey,
+            });
+            this.updateStatus(ITableStateStatusLoaded);
+        }), catchError(() => {
+            this.updateStatus(ITableStateStatusFailedToLoad);
+            return [];
+        }));
+    })));
+    createEntity = this.effect((trigger$) => trigger$.pipe(withLatestFrom(this.listEntity$, this.parent$), switchMap(([data, listEntity, parent]) => {
+        this.updateStatus(ITableStateStatusCreating);
+        return this.apiService.createEntity(data, parent).pipe(tap((response) => {
+            this.patchState({
+                listEntity: (() => {
+                    if (response.data?.parentId) {
+                        const updatedListEntity = listEntity.map((entity) => {
+                            if (entity.id === response.data.parentId) {
+                                return {
+                                    ...entity,
+                                    children: [
+                                        ...(entity.children
+                                            ? [response.data, ...entity.children]
+                                            : [response.data]),
+                                    ],
+                                };
+                            }
+                            return entity;
+                        });
+                        const parentExists = updatedListEntity.some((entity) => entity.id === response.data.parentId);
+                        if (!parentExists) {
+                            return updatedListEntity.map((entity) => ({
+                                ...entity,
+                                children: entity.children?.map((child) => child.id === response.data.parentId
+                                    ? {
+                                        ...child,
+                                        children: [
+                                            ...(child.children
+                                                ? [response.data, ...child.children]
+                                                : [response.data]),
+                                        ],
+                                    }
+                                    : child),
+                            }));
+                        }
+                        return updatedListEntity;
+                    }
+                    return [
+                        ...(response.data ? [response.data] : []),
+                        ...listEntity,
+                    ];
+                })(),
+            });
+            this.updateStatus(ITableStateStatusCreated);
+        }), catchError(() => {
+            this.updateStatus(ITableStateStatusFailedToCreate);
+            return [];
+        }));
+    })));
+    updateEntityById = this.effect((trigger$) => trigger$.pipe(withLatestFrom(this.listEntity$, this.parent$), switchMap(([data, listEntity, parent]) => {
+        this.updateStatus(ITableStateStatusUpdating);
+        return this.apiService.updateEntityById(data.id, data.entity).pipe(tap((response) => {
+            this.patchState({
+                listEntity: (() => {
+                    if (response.data?.parentId) {
+                        const updatedListEntity = listEntity.map((entity) => {
+                            if (entity.id === response.data.parentId) {
+                                return {
+                                    ...entity,
+                                    children: entity.children?.map((child) => child.id === response.data.id ? response.data : child),
+                                };
+                            }
+                            return entity;
+                        });
+                        const parentExists = updatedListEntity.some((entity) => entity.id === response.data.parentId);
+                        if (!parentExists) {
+                            return updatedListEntity.map((entity) => ({
+                                ...entity,
+                                children: entity.children?.map((child) => child.id === response.data.parentId
+                                    ? {
+                                        ...child,
+                                        children: child.children?.map((grandChild) => grandChild.id === response.data.id
+                                            ? response.data
+                                            : grandChild),
+                                    }
+                                    : child),
+                            }));
+                        }
+                        return updatedListEntity;
+                    }
+                    return listEntity.map((e) => e.id === response.data.id ? response.data : e);
+                })(),
+            });
+            this.updateStatus(ITableStateStatusUpdated);
+        }), catchError(() => {
+            this.updateStatus(ITableStateStatusFailedToUpdate);
+            return [];
+        }));
+    })));
+    deleteEntityById = this.effect((trigger$) => trigger$.pipe(withLatestFrom(this.listEntity$, this.parent$), switchMap(([id, listEntity, parent]) => {
+        this.updateStatus(ITableStateStatusDeleting);
+        return this.apiService.deleteEntityById(id).pipe(tap(() => {
+            this.patchState({
+                listEntity: listEntity.filter((e) => e.id !== id),
+            });
+            this.updateStatus(ITableStateStatusDeleted);
+        }), catchError(() => {
+            this.updateStatus(ITableStateStatusFailedToDelete);
+            return [];
+        }));
+    })));
+    // actions
+    updateEntity = this.updater((state, data) => ({
+        ...state,
+        listEntity: state.listEntity.map((e) => {
+            return e.id === data.id ? data : e;
+        }),
+    }));
+    updateStatus = this.updater((state, status) => ({
+        ...state,
+        status,
+    }));
+    setParent = this.updater((state, parent) => ({
+        ...state,
+        parent,
+    }));
+    updateSortField = this.updater((state, sort) => ({
+        ...state,
+        sort: [sort],
+    }));
+    updateFilter = this.updater((state, filter) => ({
+        ...state,
+        filter,
+    }));
+    updatePage = this.updater((state, page) => ({
+        ...state,
+        page,
+    }));
+    setExpandMode = this.updater((state, { id, mode }) => ({
+        ...state,
+        listEntity: state.listEntity.map((e) => ({
+            ...e,
+            expandMode: e.id === id ? mode : e.expandMode,
+        })),
+    }));
+    toggleExpanded = this.updater((state, { id }) => ({
+        ...state,
+        listEntity: state.listEntity.map((e) => ({
+            ...e,
+            isExpanded: e.id === id ? !(e.isExpanded || false) : e.isExpanded,
+        })),
+    }));
+    showExpanded = this.updater((state, { id }) => ({
+        ...state,
+        listEntity: state.listEntity.map((e) => ({
+            ...e,
+            isExpanded: e.id === id ? true : e.isExpanded,
+        })),
+    }));
+    hideExpanded = this.updater((state, { id }) => ({
+        ...state,
+        listEntity: state.listEntity.map((e) => ({
+            ...e,
+            isExpanded: e.id === id ? false : e.isExpanded,
+        })),
+    }));
+    toggleSelected = this.updater((state, { id }) => ({
+        ...state,
+        listEntity: state.listEntity.map((e) => ({
+            ...e,
+            isSelected: e.id === id ? !(e.isSelected || false) : e.isSelected,
+        })),
+    }));
+    constructor(initialState, apiService) {
+        super(initialState);
+        this.initialState = initialState;
+        this.apiService = apiService;
+        // this.loadListEntity();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: TableStore, deps: [{ token: 'initialState' }, { token: 'apiService' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: TableStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: TableStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['initialState']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['apiService']
+                }] }] });
+
+class GroupStore extends TableStore {
+    constructor() {
+        super({
+            isLoading: false,
+            filter: {
+                dateRange: undefined,
+                organizationId: [],
+                id: [],
+                type: [],
+                active: null,
+                approved: null,
+                keyword: '',
+            },
+            sort: [
+                {
+                    field: 'created_timestamp',
+                    direction: SearchParams.SortDirectionDesc,
+                },
+            ],
+            page: {
+                limit: 10,
+            },
+            listEntity: [],
+        }, inject(GroupApiService));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GroupStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GroupStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GroupStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class MemberStore extends TableStore {
+    constructor() {
+        super({
+            isLoading: false,
+            filter: {
+                dateRange: undefined,
+                organizationId: [],
+                groupId: [],
+                type: [],
+                active: null,
+                keyword: '',
+            },
+            sort: [
+                {
+                    field: 'created_timestamp',
+                    direction: SearchParams.SortDirectionDesc,
+                },
+            ],
+            page: {
+                limit: 10,
+            },
+            listEntity: [],
+        }, inject(MemberApiService));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: MemberStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: MemberStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: MemberStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class GlobalEffects {
+    actions$ = inject(Actions);
+    memberApiService = inject(MemberApiService);
+    globalApiService = inject(GlobalApiService);
+    groupApiService = inject(GroupApiService);
+    store = inject((Store));
+    setAuthenticated$ = createEffect(() => this.actions$.pipe(ofType(GlobalActions.setAuthenticated), withLatestFrom$1(this.store.select(GlobalSelectors.selectIsAuthenticated)), mergeMap(([action, isAuthenticated]) => {
+        if (isAuthenticated) {
+            this.store.dispatch(GlobalActions.increaseLoadingReference());
+            return forkJoin({
+                profile: this.memberApiService.getProfile(),
+                acl: this.globalApiService.getAcl(),
+                listMenuItem: this.globalApiService.getListMenuItem(),
+            }).pipe(mergeMap(({ profile, acl, listMenuItem }) => {
+                const groupId = profile.data.groupId;
+                return this.groupApiService.getEntityById(groupId).pipe(mergeMap((group) => [
+                    GlobalActions.setProfile({ profile: profile.data }),
+                    GlobalActions.setAcl({ acl: acl.data }),
+                    GlobalActions.setListMenuItem({
+                        listMenuItem: listMenuItem.data,
+                    }),
+                    GlobalActions.setCurrentGroup({ group: group.data }),
+                    GlobalActions.markInitiated({ initiated: true }),
+                ]));
+            }), catchError$1(() => of(GlobalActions.clearAuthentication())), finalize(() => {
+                this.store.dispatch(GlobalActions.decreaseLoadingReference());
+            }));
+        }
+        return of(GlobalActions.clearAuthentication());
+    })));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GlobalEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GlobalEffects });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: GlobalEffects, decorators: [{
+            type: Injectable
+        }] });
+
+const initialState = {
+    initiated: false,
+    isAuthenticated: false,
+    loadingReference: 0,
+    acl: {},
+    listMenuItem: [],
+    isSideMenuOpen: false,
+    language: 'en', // TODO: Use a proper language management system
+    profile: undefined,
+    currentGroup: undefined,
+};
+
+const globalReducer = createReducer(initialState, on(GlobalActions.markInitiated, (state) => ({
+    ...state,
+    initiated: true,
+})), on(GlobalActions.setAuthenticated, (state, { isAuthenticated }) => ({
+    ...state,
+    isAuthenticated,
+})), on(GlobalActions.setProfile, (state, { profile }) => ({
+    ...state,
+    profile,
+})), on(GlobalActions.increaseLoadingReference, (state) => ({
+    ...state,
+    loadingReference: state.loadingReference + 1,
+})), on(GlobalActions.decreaseLoadingReference, (state) => ({
+    ...state,
+    loadingReference: Math.max(state.loadingReference - 1, 0),
+})), on(GlobalActions.setAcl, (state, { acl }) => ({
+    ...state,
+    acl,
+})), on(GlobalActions.setListMenuItem, (state, { listMenuItem }) => ({
+    ...state,
+    listMenuItem,
+})), on(GlobalActions.toggleSideMenu, (state) => ({
+    ...state,
+    isSideMenuOpen: !state.isSideMenuOpen,
+})), on(GlobalActions.closeSideMenu, (state) => ({
+    ...state,
+    isSideMenuOpen: false,
+})), on(GlobalActions.setLanguage, (state, { language }) => ({
+    ...state,
+    language,
+})), on(GlobalActions.setCurrentGroup, (state, { group }) => ({
+    ...state,
+    currentGroup: group,
+})));
+
+/*
+ * Public API Surface of core
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AuthService, BaseEntityApiService, CdnApiService, CoreService, DisplayNamePipe, GlobalActions, GlobalApiService, GlobalEffects, GlobalSelectors, GroupApiService, GroupStore, HALODUCK_CORE_CONFIG, ITableStateStatusCreated, ITableStateStatusCreating, ITableStateStatusDeleted, ITableStateStatusDeleting, ITableStateStatusFailedToCreate, ITableStateStatusFailedToDelete, ITableStateStatusFailedToLoad, ITableStateStatusFailedToUpdate, ITableStateStatusLoaded, ITableStateStatusLoading, ITableStateStatusUpdated, ITableStateStatusUpdating, MemberApiService, MemberStore, SearchParams, TableStore, authGuard, defaultLanguage, dummyMemberIdInterceptor, errorHandler, globalReducer, groupIdInterceptor, idTokenInterceptor, initialState, provideHaloduckCoreConfig, responseHandler, supportedLanguages };
+//# sourceMappingURL=haloduck-core.mjs.map