@servicetitan/standalone-root 1.2.0 → 1.4.0

package/src/stores/standalone-root.store.ts

@@ -6,7 +6,7 @@ import {
     PartitionsClientApi,
     UserDetails,
 } from '@servicetitan/marketing-services-api/identity';
-import { LoadStatus } from '@servicetitan/standalone-ui';
+import { LoadStatus, SymbolTokenDataType } from '@servicetitan/standalone-ui';
 import { inject, injectable } from '@servicetitan/react-ioc';
 import {
     AppConfigApi,
@@ -26,8 +26,10 @@ import {
     storageKeyForAppSettings,
     storageKeyForTenantConfigs,
 } from '../utils/storage-keys';
+import { ModifiableRootSection } from '../enums';
+import { POSSIBLE_CHANGES_TOKEN } from '../utils/tokens';
 import { cultureKeyInCoreConfigs, defaultLocale, defaultTimezone } from '../utils/constants';
-import { currentInstanceSymbol, eventEmitterSymbol, isInitializedSymbol } from '../utils/symbols';
+import { eventEmitterSymbol, isInitializedSymbol, registeredChangesSymbol } from '../utils/symbols';
 
 @injectable()
 export class StandaloneRootStore {
@@ -42,19 +44,22 @@ export class StandaloneRootStore {
     @observable locale = defaultLocale;
 
     private eventEmitter!: EventEmitter;
+    private currentInstanceSymbol = Symbol();
 
     constructor(
         @inject(TenantManagementApi) private readonly tenantManagementApi: TenantManagementApi,
         @inject(AppConfigApi) private readonly appConfigApi: AppConfigApi,
         @inject(CurrentUserClientApi) private readonly currentUserClientApi: CurrentUserClientApi,
         @inject(OnboardingApi) private readonly onboardingApi: OnboardingApi,
-        @inject(PartitionsClientApi) private partitionsApi: PartitionsClientApi,
+        @inject(PartitionsClientApi) private readonly partitionsApi: PartitionsClientApi,
+        @inject(POSSIBLE_CHANGES_TOKEN)
+        private readonly possibleChanges: SymbolTokenDataType<typeof POSSIBLE_CHANGES_TOKEN>,
     ) {
         this.initializeEventEmitter();
         makeObservable(this);
     }
 
-    initialize = async (forceRefresh: boolean, refreshOnboarding: boolean) => {
+    initialize = async (forceRefresh: boolean) => {
         try {
             runInAction(() => {
                 this.loadStatus = LoadStatus.Loading;
@@ -95,8 +100,12 @@ export class StandaloneRootStore {
                 const isSuccess = this.syncFromStorage();
 
                 if (isSuccess) {
-                    if (refreshOnboarding) {
-                        await this.fetchOnboarding();
+                    if (this.registeredChanges?.length) {
+                        await Promise.all(
+                            this.registeredChanges.map(section =>
+                                this.mapModifiableSectionToFetcher[section](),
+                            ),
+                        );
                     }
                 } else {
                     await fetchAll();
@@ -107,11 +116,13 @@ export class StandaloneRootStore {
                 this.setIsInitialized(true);
             }
 
+            this.removeRegisteredChanges();
+
             const timezoneFetched = this.tenantConfigs.TimeZone;
 
             if (timezoneFetched) {
                 runInAction(() => {
-                    this.timezone = this.tenantConfigs.TimeZone;
+                    this.timezone = timezoneFetched;
                 });
             }
 
@@ -146,7 +157,22 @@ export class StandaloneRootStore {
         };
     }
 
-    unregisterGlobalSyncListener = () => {
+    dispose = () => {
+        this.registerPossibleChanges();
+        this.unregisterGlobalSyncListener();
+    };
+
+    private registerPossibleChanges = () => {
+        if (this.possibleChanges?.length) {
+            (window as any)[registeredChangesSymbol] = this.possibleChanges;
+        }
+    };
+
+    private removeRegisteredChanges = () => {
+        (window as any)[registeredChangesSymbol] = undefined;
+    };
+
+    private unregisterGlobalSyncListener = () => {
         this.eventEmitter.off(Events.SyncFromStorage, this.listenGlobalSync);
     };
 
@@ -166,13 +192,13 @@ export class StandaloneRootStore {
     };
 
     private listenGlobalSync = (instanceSymbol: symbol) => {
-        if (instanceSymbol !== currentInstanceSymbol) {
+        if (instanceSymbol !== this.currentInstanceSymbol) {
             this.syncFromStorage();
         }
     };
 
     private emitGlobalSync = () => {
-        this.eventEmitter.emit(Events.SyncFromStorage, currentInstanceSymbol);
+        this.eventEmitter.emit(Events.SyncFromStorage, this.currentInstanceSymbol);
     };
 
     private syncFromStorage = () => {
@@ -225,10 +251,6 @@ export class StandaloneRootStore {
         (window as any)[isInitializedSymbol] = value;
     };
 
-    private get isInitialized() {
-        return !!(window as any)[isInitializedSymbol];
-    }
-
     private fetchTenant = async () => {
         const tenantFetched = await this.tenantManagementApi.client.tenant(undefined);
 
@@ -295,4 +317,18 @@ export class StandaloneRootStore {
             this.partitions = partitionsFetched;
         });
     };
+
+    private get isInitialized() {
+        return !!(window as any)[isInitializedSymbol];
+    }
+
+    private get registeredChanges(): typeof this.possibleChanges {
+        return (window as any)[registeredChangesSymbol];
+    }
+
+    private get mapModifiableSectionToFetcher(): Record<ModifiableRootSection, () => void> {
+        return {
+            [ModifiableRootSection.Onboarding]: this.fetchOnboarding,
+        };
+    }
 }

package/src/utils/symbols.ts

@@ -1,6 +1,7 @@
 const rootSymbolKey = 'standalone-root-symbol-key';
 const eventEmitterSymbolKey = 'standalone-root-event-emitter-symbol-key';
+const registeredChangesSymbolKey = 'standalone-root-modifiable-changes-symbol-key';
 
 export const isInitializedSymbol = Symbol.for(rootSymbolKey);
 export const eventEmitterSymbol = Symbol.for(eventEmitterSymbolKey);
-export const currentInstanceSymbol = Symbol();
+export const registeredChangesSymbol = Symbol.for(registeredChangesSymbolKey);

package/src/utils/tokens.ts

@@ -0,0 +1,7 @@
+import { symbolToken } from '@servicetitan/react-ioc';
+import { ModifiableRootSection } from '../enums';
+
+export const POSSIBLE_CHANGES_TOKEN = symbolToken<ModifiableRootSection[] | undefined>(
+    'POSSIBLE_CHANGES_TOKEN',
+    false,
+);