chronograph-npm 0.2.0 → 0.2.1

package/README.md

@@ -36,7 +36,7 @@ class MyApp extends Homey.App {
 module.exports = MyApp;
 ```
 
-`CG.init` accepts one option, `homey`, which must be the Homey instance. It returns a `CG` instance and registers a realtime listener. It does not fetch chronographs during initialization; call `CG.getChronographs()` or `CG.getAllChronographs()` when you need that data. When Homey emits `unload` as the consuming app stops, `CG.destroy()` is called automatically to remove the listeners, without replacing your app's lifecycle methods. Cleanup cannot be guaranteed if the process is forcibly terminated.
+`CG.init` accepts one option, `homey`, which must be the Homey instance. It checks that Chronograph is installed and responding to its `/chronographs` API before registering a realtime listener. This checks availability during initialization, not continuously afterward. The response is discarded; call `CG.getChronographs()` or `CG.getAllChronographs()` when you need that data. If a check fails, the error is logged, `isReady` remains false, and `ready` remains pending; call `instance.init()` to retry. When Homey emits `unload` as the consuming app stops, `CG.destroy()` is called automatically to remove the listeners, without replacing your app's lifecycle methods. Cleanup cannot be guaranteed if the process is forcibly terminated.
 
 ## Available API
 
@@ -49,7 +49,7 @@ The package exports the `CG` class:
 | `CG.getAllChronographs()` | Returns configured chronograph names grouped by type, such as `timer`, `stopwatch`, and `transition`. |
 | `CG.onChronographUpdate({ chronograph })` | Update hook. Override it to handle realtime updates; the default implementation does nothing. |
 | `CG.destroy()` | Removes the realtime and unload listeners. Called automatically on Homey's `unload` event; can also be called manually. |
-| `instance.ready` / `CG.ready` | Promise that resolves after successful initialization and realtime-listener registration. |
+| `instance.ready` / `CG.ready` | Promise that resolves after the installation and API checks and realtime-listener registration succeed. |
 | `instance.isReady` / `CG.isReady` | Indicates whether the integration has become ready. |
 
 For example, retrieve active chronographs after initialization:
@@ -93,4 +93,4 @@ module.exports = MyApp;
 - The Chronograph app must be installed on the same Homey.
 - Your app must declare the Chronograph permission in `app.json`.
 - Initialize the package with your app's Homey instance before calling the retrieval methods.
-- Initialization only registers for realtime updates; fetch chronograph data explicitly using the retrieval methods.
+- Initialization checks the Chronograph API and registers for realtime updates; fetch chronograph data explicitly using the retrieval methods.

package/dist/cg.d.ts

@@ -54,6 +54,8 @@ export class CG {
     });
     homey: any;
     isReady: boolean;
+    _destroyed: boolean;
+    _defer: Defer;
     ready: any;
     init({}?: {}): Promise<CG>;
     api: any;
@@ -61,4 +63,25 @@ export class CG {
     /** @private */
     private getAppApi;
 }
+declare class Defer {
+    /**
+     * @param {Number} timeout
+     */
+    constructor(timeout: number, originalPromise: any, onTimeout: any);
+    set isDefered(arg: boolean);
+    get isDefered(): boolean;
+    _isDefered: any;
+    set promise(arg: any);
+    get promise(): any;
+    _promise: any;
+    _resolve: any;
+    _reject: any;
+    timeout: any;
+    then(fun: any): Defer;
+    catch(fun: any): Defer;
+    finally(fun: any): Defer;
+    resolve(val1: any, val2: any, val3: any, val4: any): any;
+    reject(val1: any, val2: any, val3: any, val4: any): any;
+}
+export {};
 //# sourceMappingURL=cg.d.ts.map

package/dist/cg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cg.d.ts","sourceRoot":"","sources":["../src/cg.js"],"names":[],"mappings":"AAAA;IAGI;;oBAWC;IA+BD;;OAEG;IACH,uBASC;IAuCD,0CAEC;IAED,uCAEC;IAKD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;QAlB0B,WAAW;YACE,EAAE,GAA9B,MAAM;YACqB,IAAI,EAA/B,MAAM;YACqB,QAAQ,EAAnC,MAAM;YACqB,OAAO,EAAlC,MAAM;YAC0B,cAAc,EAA9C,MAAM,GAAC,IAAI;YAEqB,SAAS,EAAzC,MAAM,GAAC,IAAI;YAEiB,OAAO,EAAnC,OAAO;YACqB,OAAO,EAAnC,OAAO;YACkB,GAAG,EAA5B,IAAI;YACuB,IAAI;gBAC4B,IAAI,GAA/D,OAAO,GAAC,WAAW,GAAC,YAAY;gBACC,IAAI,GAArC,MAAM;gBAC2B,EAAE,GAAnC,MAAM;gBAC2B,KAAK,GAAtC,MAAM;;;sBAKhB;IArHD;;OAWC;IATG,WAA6B;IAC7B,iBAAoB;IAIpB,WAAyC;IAM7C,2BAaC;IAVW,SAAqC;IA6BjD,uDAcC;IAGD,eAAe;IACf,kBAeC;CA2CJ"}
+{"version":3,"file":"cg.d.ts","sourceRoot":"","sources":["../src/cg.js"],"names":[],"mappings":"AAAA;IAGI;;oBAOC;IAkCD;;OAEG;IACH,uBAUC;IA2BD,0CAEC;IAED,uCAEC;IAKD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;QAlB0B,WAAW;YACE,EAAE,GAA9B,MAAM;YACqB,IAAI,EAA/B,MAAM;YACqB,QAAQ,EAAnC,MAAM;YACqB,OAAO,EAAlC,MAAM;YAC0B,cAAc,EAA9C,MAAM,GAAC,IAAI;YAEqB,SAAS,EAAzC,MAAM,GAAC,IAAI;YAEiB,OAAO,EAAnC,OAAO;YACqB,OAAO,EAAnC,OAAO;YACkB,GAAG,EAA5B,IAAI;YACuB,IAAI;gBAC4B,IAAI,GAA/D,OAAO,GAAC,WAAW,GAAC,YAAY;gBACC,IAAI,GAArC,MAAM;gBAC2B,EAAE,GAAnC,MAAM;gBAC2B,KAAK,GAAtC,MAAM;;;sBAKhB;IA7GD;;OAaC;IAXG,WAA6B;IAChB,iBAAoB;IACjC,oBAAuB;IAEvB,cAAqC;IAErC,WAA2C;IAO/C,2BAcC;IARW,SAAc;IA4B1B,uDAYC;IAGD,eAAe;IACf,kBAKC;CA2CJ;AAID;IAMI;;OAEG;IACH,mEAeC;IAtBD,4BAAyC;IADzC,yBAA6C;IAC1B,gBAAmB;IAGtC,sBAAqC;IADrC,mBAAuC;IACtB,cAAiB;IAM1B,cAAuB;IACvB,aAAqB;IAGrB,aAMsB;IAI9B,sBAAmD;IACnD,uBAAqD;IACrD,yBAAyD;IACzD,yDAAoK;IACpK,wDAAkK;CACrK"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chronograph-npm",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The Chronograph App for Athom's Homey",
   "main": "src/cg.js",
   "types": "./dist/cg.d.ts",

package/src/cg.js

@@ -6,33 +6,32 @@ class CG {
         let cg = new CG({ homey });
 
         homey.once('unload', CG.destroy);
-        try {
-            await cg.init();
-        } catch (error) {
-
-        }
+        await cg.init();
         return cg;
     }
     constructor({ homey }) {
         CG.Current = this;
         this.homey = CG.homey = homey;
-        this.isReady = false;
+        CG.isReady = this.isReady = false;
+        this._destroyed = false;
 
-        CG._defer = new Defer();
+        this._defer = CG._defer = new Defer();
 
-        this.ready = CG.ready = CG._defer.promise;
-        CG.ready.then(() => {
-            CG.isReady = this.isReady = true;
+        this.ready = CG.ready = this._defer.promise;
+        this.ready.then(() => {
+            this.isReady = true;
+            if (CG.Current === this) CG.isReady = true;
         });
     }
 
     async init({ } = {}) {
         if (!this.api) {
             try {
-                this.api = await this.getAppApi(true);
-                this.api.on('realtime', this.realtimeFunction);
-                //await this.api.get('/chronographs')
-                if (!CG.isReady && CG._defer) CG._defer.resolve();
+                const api = await this.getAppApi();
+                if (this._destroyed) return this;
+                api.on('realtime', this.realtimeFunction);
+                this.api = api;
+                this._defer.resolve();
             } catch (error) {
                 this.homey.error('CG.init', error);
                 return this;
@@ -49,6 +48,7 @@ class CG {
     static destroy() {
         try {
             if (!CG.Current) return;
+            CG.Current._destroyed = true;
             CG.Current.homey.removeListener('unload', CG.destroy);
             if (CG.Current.api) {
                 CG.Current.api.off('realtime', CG.Current.realtimeFunction);
@@ -59,8 +59,6 @@ class CG {
 
 
     async realtimeFunction(event, data) {
-        if (!CG.isReady && CG._defer) CG._defer.resolve();
-
         if (event === 'chronograph_event') {
             if (data && data.now) data.now = new Date(data.now);
             CG.onChronographUpdate({ chronograph: data });
@@ -76,21 +74,11 @@ class CG {
 
 
     /** @private */
-    async getAppApi(onlyApi) {
-        try {
-            if (!this.api) this.api = this.homey.api.getApiApp('nl.fellownet.chronograph');
-        } catch (error) {
-            throw new Error(error);
-        }
-        if (onlyApi === true) return this.api;
-        if (!this.api) throw new Error('Chronograph is not installed.');
-        else {
-            try {
-                BL._isLoaded = await this.api.getInstalled();
-            } catch (error) { }
-            if (!BL._isLoaded) throw new Error('Chronograph is not installed.');
-        }
-        return this.api;
+    async getAppApi() {
+        const api = this.homey.api.getApiApp('nl.fellownet.chronograph');
+        if (!api || !await api.getInstalled()) throw new Error('Chronograph is not installed.');
+        await api.get('/chronographs');
+        return api;
     }
 
 

package/test/cg.test.js

@@ -6,12 +6,129 @@ const { CG } = require('../src/cg');
 function createHomey() {
     const homey = new EventEmitter();
     const api = new EventEmitter();
+    api.getInstalled = async () => true;
+    api.get = async () => [];
     homey.api = { getApiApp: () => api };
     homey.app = { onUninit() {} };
     homey.error = (...args) => assert.fail(args.join(' '));
     return { homey, api };
 }
 
+test('readiness requires Chronograph to be installed and supports retry', async (t) => {
+    const { homey, api } = createHomey();
+    const errors = [];
+    homey.error = (...args) => errors.push(args);
+    let installed = false;
+    api.getInstalled = async () => installed;
+    t.after(() => CG.destroy());
+
+    const cg = await CG.init({ homey });
+    let resolved = false;
+    cg.ready.then(() => { resolved = true; });
+    await cg.realtimeFunction('other');
+
+    assert.equal(cg.isReady, false);
+    assert.equal(CG.isReady, false);
+    assert.equal(resolved, false);
+    assert.equal(api.listenerCount('realtime'), 0);
+    assert.match(errors[0][1].message, /not installed/);
+
+    installed = true;
+    await cg.init();
+    await cg.ready;
+    assert.equal(cg.isReady, true);
+    assert.equal(CG.isReady, true);
+    assert.equal(api.listenerCount('realtime'), 1);
+});
+
+test('an installation check failure leaves readiness false and logs the error', async (t) => {
+    const { homey, api } = createHomey();
+    const failure = new Error('installation check failed');
+    const errors = [];
+    homey.error = (...args) => errors.push(args);
+    api.getInstalled = async () => { throw failure; };
+    t.after(() => CG.destroy());
+
+    const cg = await CG.init({ homey });
+    assert.equal(cg.isReady, false);
+    assert.equal(CG.isReady, false);
+    assert.equal(api.listenerCount('realtime'), 0);
+    assert.equal(errors[0][1], failure);
+});
+
+test('readiness requires the installed app to respond to its API', async (t) => {
+    const { homey, api } = createHomey();
+    const failure = new Error('app is not running');
+    const errors = [];
+    homey.error = (...args) => errors.push(args);
+    let running = false;
+    const paths = [];
+    api.get = async (path) => {
+        paths.push(path);
+        if (!running) throw failure;
+        return [];
+    };
+    t.after(() => CG.destroy());
+
+    const cg = await CG.init({ homey });
+    assert.equal(cg.isReady, false);
+    assert.equal(CG.isReady, false);
+    assert.equal(api.listenerCount('realtime'), 0);
+    assert.equal(errors[0][1], failure);
+    assert.deepEqual(paths, ['/chronographs']);
+
+    running = true;
+    await cg.init();
+    await cg.ready;
+    assert.equal(cg.isReady, true);
+    assert.equal(CG.isReady, true);
+    assert.deepEqual(paths, ['/chronographs', '/chronographs']);
+    assert.equal(api.listenerCount('realtime'), 1);
+});
+
+test('readiness remains false while the running check is pending', async (t) => {
+    const { homey, api } = createHomey();
+    let finishRequest;
+    let requestStarted;
+    const started = new Promise(resolve => { requestStarted = resolve; });
+    api.get = () => {
+        requestStarted();
+        return new Promise(resolve => { finishRequest = resolve; });
+    };
+    t.after(() => CG.destroy());
+
+    const initializing = CG.init({ homey });
+    await started;
+    assert.equal(CG.Current.isReady, false);
+    assert.equal(CG.isReady, false);
+    assert.equal(api.listenerCount('realtime'), 0);
+
+    finishRequest([]);
+    const cg = await initializing;
+    assert.equal(cg.isReady, true);
+    assert.equal(CG.isReady, true);
+});
+
+test('a replaced initialization cannot become ready after its check completes', async (t) => {
+    const first = createHomey();
+    const second = createHomey();
+    let finishCheck;
+    first.api.getInstalled = () => new Promise(resolve => { finishCheck = resolve; });
+    second.api.getInstalled = async () => false;
+    second.homey.error = () => {};
+    t.after(() => CG.destroy());
+
+    const firstInit = CG.init({ homey: first.homey });
+    const secondCg = await CG.init({ homey: second.homey });
+    finishCheck(true);
+    const firstCg = await firstInit;
+
+    assert.equal(firstCg.isReady, false);
+    assert.equal(secondCg.isReady, false);
+    assert.equal(CG.isReady, false);
+    assert.equal(first.api.listenerCount('realtime'), 0);
+});
+
 test('unload removes the realtime listener without replacing app lifecycle methods', async (t) => {
     const { homey, api } = createHomey();
     const onUninit = homey.app.onUninit;