arcane-os 0.2.2 → 0.3.0

package/runtime/arcane/modules/TimeGuard.js

@@ -1,10 +1,35 @@
 import Is from '../../node_modules/strong-type/index.js';
 import './DBOPFS.js';
 import UserEntity from '../entities/User.js';
+import {
+    arcaneEvents,
+    createArcaneEventSource,
+    projectArcaneDOMEvent
+} from 'arcane-os/event-manager';
 
 const is=new Is(false);
+const PUBLISH_TIME_GUARD_READY=Symbol('publish-time-guard-ready');
+const USER_ENTITY_LOADED_EVENT='user-entity-loaded';
+const TIME_GUARD_READY_EVENT='time-guard-ready';
+const TIME_GUARD_READY_REASON='time-guard-initialized';
+let userReadyUnsubscribe=null;
+
+function timeGuardError(code,reason,message,ErrorConstructor=Error){
+    const error=new ErrorConstructor(message);
+    error.code=code;
+    error.reason=reason;
+    return error;
+}
 
 class TimeGuard {
+    #events;
+
+    #disposed=false;
+
+    #operationSequence=0;
+
+    ready=false;
+
     // Default to 17 day grace period from last check
     #gracePeriod = 1000 * 60 * 60 * 24 * 17;
     //                 ms    s    m    h    d
@@ -22,9 +47,23 @@ class TimeGuard {
             return window.timeguard;
         }
 
+        this.#events=createArcaneEventSource(this,{
+            source:'time-guard',
+            eventTypes:Object.freeze([TIME_GUARD_READY_EVENT])
+        });
         this.#loadTime();
     }
 
+    #assertOpen(){
+        if(this.#disposed){
+            throw timeGuardError(
+                'ARCANE_TIME_GUARD_DISPOSED',
+                'time-guard-disposed',
+                'The time guard has been disposed.'
+            );
+        }
+    }
+
     #loadTime() {
         this.#storedTime = window.user?.current_time || 0;
         this.#lastSuccessfulTime = window.user?.last_successful_time || 0;
@@ -48,15 +87,26 @@ class TimeGuard {
 
     #checkTime(time=0) {
         if(!is.number(time)) {
-            throw new Error('time must be number')
+            throw timeGuardError(
+                'ARCANE_TIME_GUARD_TIME_VALUE_TYPE_MISMATCH',
+                'time-value-type-mismatch',
+                'Time guard values must be numbers.',
+                TypeError
+            );
         }
 
         if (!time) {
-            throw new Error('time must be supplied');
+            throw timeGuardError(
+                'ARCANE_TIME_GUARD_TIME_VALUE_REQUIRED',
+                'time-value-required',
+                'A nonzero time guard value is required.',
+                RangeError
+            );
         }
     }
 
     setStoredTime(time=0) {
+        this.#assertOpen();
         this.#checkTime(time);
 
         if (time < this.#storedTime) {
@@ -70,11 +120,17 @@ class TimeGuard {
     }
 
     setLastSuccessfulCheckTime(time=0) {
+        this.#assertOpen();
         this.#checkTime(time);
 
         if (time < this.#lastSuccessfulTime) {
             //console.log('Clock rollback detected');
-            throw new Error('current time must be greater than last time check');
+            throw timeGuardError(
+                'ARCANE_TIME_GUARD_SUCCESS_TIME_ROLLBACK',
+                'successful-check-time-rollback',
+                'The successful-check time cannot precede its stored value.',
+                RangeError
+            );
         }
 
         this.#lastSuccessfulTime = time;
@@ -84,26 +140,38 @@ class TimeGuard {
     }
 
     checkClockRollback() {
+        this.#assertOpen();
         // Get current time and add time change grace period.
         // This is to allow for time changes up to six hours
         const currentTimeWithTimeChangeGracePeriod = Date.now() + this.#gracePeriodClock;
 
         if (currentTimeWithTimeChangeGracePeriod < this.#storedTime) {
             //console.log('Clock rollback detected');
-            throw new Error('Clock has been rolled back greater than six hours from last check');
+            throw timeGuardError(
+                'ARCANE_TIME_GUARD_CLOCK_ROLLBACK_LIMIT_EXCEEDED',
+                'clock-rollback-limit-exceeded',
+                'The clock precedes the stored time by more than the allowed tolerance.',
+                RangeError
+            );
         }
 
         return true;
     }
 
     checkGracePeriod() {
+        this.#assertOpen();
         this.checkClockRollback();
 
         const currentTime = Date.now();
 
         if (currentTime < this.#lastSuccessfulTime) {
             //console.log('Clock rollback detected');
-            throw new Error('current time must be greater than last time check')
+            throw timeGuardError(
+                'ARCANE_TIME_GUARD_CURRENT_TIME_PRECEDES_SUCCESS',
+                'current-time-precedes-successful-check',
+                'The current time precedes the last successful check.',
+                RangeError
+            );
         }
 
         const timeDifferenceBetweenChecks = currentTime - this.#lastSuccessfulTime;
@@ -112,38 +180,81 @@ class TimeGuard {
 
         // Note, if the last known time check has not been set, this error will always be emitted
         if (timeDifferenceBetweenChecks > this.#gracePeriod) {
-            throw new Error('Grace period time has been exceeded or key is invalid');
+            throw timeGuardError(
+                'ARCANE_TIME_GUARD_GRACE_PERIOD_EXCEEDED',
+                'grace-period-exceeded',
+                'The elapsed time exceeds the allowed time guard grace period.',
+                RangeError
+            );
         }
 
         return true;
     }
-}
 
+    [PUBLISH_TIME_GUARD_READY](){
+        this.#assertOpen();
+        const operationId=`${this.#events.instanceId}:initialize:${(++this.#operationSequence).toString(36)}`;
+        const {occurrence}=this.#events.dispatch(
+            TIME_GUARD_READY_EVENT,
+            Object.freeze({
+                db:this,
+                reason:TIME_GUARD_READY_REASON
+            }),
+            {
+                operationId,
+                publicDetail:Object.freeze({
+                    ready:true,
+                    reason:TIME_GUARD_READY_REASON
+                })
+            }
+        );
+        projectArcaneDOMEvent(window,occurrence);
+    }
+
+    dispose(){
+        if(this.#disposed)return false;
+        this.#disposed=true;
+        this.ready=false;
+        if(window.timeguard===this)delete window.timeguard;
+        return this.#events.dispose();
+    }
+
+    destroy(){
+        return this.dispose();
+    }
+}
 
-window.addEventListener(
-    'user-entity-loaded',
-    instantiateTimeGuard
-);
+function connectTimeGuardToUser(){
+    if(window.user?.ready){
+        instantiateTimeGuard();
+        return;
+    }
 
-if(window.user?.ready){
-    instantiateTimeGuard();
+    if(userReadyUnsubscribe)return;
+    userReadyUnsubscribe=arcaneEvents.subscribe(
+        USER_ENTITY_LOADED_EVENT,
+        instantiateTimeGuard,
+        {once:true}
+    );
 }
 
 function instantiateTimeGuard() {
+    userReadyUnsubscribe=null;
+    if(!window.user?.ready){
+        connectTimeGuardToUser();
+        return;
+    }
+
     if(!window.timeguard){
         window.timeguard = new TimeGuard();
 
         window.timeguard.ready = true;
 
-        const timeguardReady = new CustomEvent(
-            'time-guard-ready', {
-                detail: { db: window.timeguard }
-            }
-        );
-
-        window.dispatchEvent(timeguardReady);
+        window.timeguard[PUBLISH_TIME_GUARD_READY]();
 
     }
 }
 
+connectTimeGuardToUser();
+
 export default TimeGuard;