homebridge-nanoleaf-multi 1.0.0

package/dist/index.js.LICENSE.txt

@@ -0,0 +1,17 @@
+/*! ReadWriteLock - v5.0.0 - 2015-01-16
+ * Author: Alberto La Rocca <a71104@gmail.com> (https://github.com/71104)
+ * Released under the MIT license
+ * Copyright (c) 2015 Alberto La Rocca */
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+//! moment.js
+
+//! moment.js locale configuration

package/dist/platformFactory.d.ts

@@ -0,0 +1,12 @@
+import { PlatformConfiguration, Context } from './types';
+import Zone from './Zone';
+declare const _default: (homebridge: any) => {
+    new (homebridgeLog: any, configuration: PlatformConfiguration): {
+        context: Context;
+        zones: Map<string, Zone>;
+        readonly allEffects: import("./Effect").default<any>[];
+        readonly configuration: PlatformConfiguration;
+        accessories(callback: any): Promise<void>;
+    };
+};
+export default _default;

package/dist/types/Context.d.ts

@@ -0,0 +1,9 @@
+import { PaletteClient } from '@manganese/palette-kit-client';
+import { Palette } from '@manganese/palette-kit-core';
+import SimpleLogger from 'simple-node-logger';
+export default interface Context {
+    homebridge: any;
+    palette: Palette;
+    paletteClient: PaletteClient;
+    log: SimpleLogger.Logger;
+}

package/dist/types/PlatformConfiguration.d.ts

@@ -0,0 +1,6 @@
+import { ClientConfiguration } from '@manganese/palette-kit-client';
+import { ZoneConfiguration } from './devices';
+export default interface PlatformConfiguration {
+    paletteClient: ClientConfiguration;
+    zones: ZoneConfiguration[];
+}

package/dist/types/devices/DeviceConfiguration.d.ts

@@ -0,0 +1,7 @@
+export default interface DeviceConfiguration {
+    id: string;
+    name: string;
+    ip: string;
+    token: string;
+    size?: number;
+}

package/dist/types/devices/ZoneConfiguration.d.ts

@@ -0,0 +1,8 @@
+import DeviceConfiguration from './DeviceConfiguration';
+import EffectConfiguration from '../effects/EffectConfiguration';
+export default interface ZoneConfiguration {
+    id: string;
+    name: string;
+    devices: DeviceConfiguration[];
+    effects: EffectConfiguration[];
+}

package/dist/types/devices/index.d.ts

@@ -0,0 +1,3 @@
+import ZoneConfiguration from './ZoneConfiguration';
+import DeviceConfiguration from './DeviceConfiguration';
+export { ZoneConfiguration, DeviceConfiguration };

package/dist/types/effects/ConstantEffectColorConfiguration.d.ts

@@ -0,0 +1,4 @@
+import { ConstantColorConfiguration } from '@manganese/palette-kit-core';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+type ConstantEffectColorConfiguration<AdditionalConfigurationType = {}> = ConstantColorConfiguration<EffectColorConfigurationBase & AdditionalConfigurationType>;
+export default ConstantEffectColorConfiguration;

package/dist/types/effects/DynamicEffectColorConfiguration.d.ts

@@ -0,0 +1,6 @@
+import { DynamicColorConfiguration } from '@manganese/palette-kit-core';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+type DynamicEffectColorConfiguration<AdditionalConfigurationType = {}> = DynamicColorConfiguration<EffectColorConfigurationBase & AdditionalConfigurationType & {
+    name: string;
+}>;
+export default DynamicEffectColorConfiguration;

package/dist/types/effects/EffectColorConfiguration.d.ts

@@ -0,0 +1,5 @@
+import ConstantEffectColorConfiguration from './ConstantEffectColorConfiguration';
+import DynamicEffectColorConfiguration from './DynamicEffectColorConfiguration';
+import RemoteEffectColorConfiguration from './RemoteEffectColorConfiguration';
+type EffectColorConfiguration = ConstantEffectColorConfiguration | DynamicEffectColorConfiguration | RemoteEffectColorConfiguration;
+export default EffectColorConfiguration;

package/dist/types/effects/EffectColorConfigurationBase.d.ts

@@ -0,0 +1,3 @@
+export default interface EffectColorConfigurationBase {
+    probability?: number;
+}

package/dist/types/effects/EffectColorType.d.ts

@@ -0,0 +1,6 @@
+import { ClientColorType } from '@manganese/palette-kit-client';
+declare enum NativeColorType {
+    Native = "native"
+}
+type EffectColorType = ClientColorType | NativeColorType;
+export default EffectColorType;

package/dist/types/effects/EffectConfiguration.d.ts

@@ -0,0 +1,5 @@
+import { RandomEffectConfiguration } from './random-effect';
+import { SolidEffectConfiguration } from './solid-effect';
+import { WaveEffectConfiguration } from './wave-effect';
+type EffectConfiguration = SolidEffectConfiguration | WaveEffectConfiguration | RandomEffectConfiguration;
+export default EffectConfiguration;

package/dist/types/effects/EffectConfigurationBase.d.ts

@@ -0,0 +1,8 @@
+import EffectType from './EffectType';
+export default interface EffectConfigurationBase {
+    type: EffectType;
+    name: string;
+    id: string;
+    nativeName?: string;
+    hapIdentifier: number;
+}

package/dist/types/effects/EffectType.d.ts

@@ -0,0 +1,6 @@
+declare enum EffectType {
+    Solid = "solid",
+    Wave = "wave",
+    Random = "random"
+}
+export default EffectType;

package/dist/types/effects/RemoteEffectColorConfiguration.d.ts

@@ -0,0 +1,4 @@
+import { RemoteColorConfiguration } from '@manganese/palette-kit-client';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+type RemoteEffectColorConfiguration<AdditionalConfigurationType = {}> = RemoteColorConfiguration<EffectColorConfigurationBase & AdditionalConfigurationType>;
+export default RemoteEffectColorConfiguration;

package/dist/types/effects/index.d.ts

@@ -0,0 +1,14 @@
+import EffectType from './EffectType';
+import EffectConfiguration from './EffectConfiguration';
+import EffectConfigurationBase from './EffectConfigurationBase';
+import EffectColorType from './EffectColorType';
+import EffectColorConfiguration from './EffectColorConfiguration';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+import ConstantEffectColorConfiguration from './ConstantEffectColorConfiguration';
+import DynamicEffectColorConfiguration from './DynamicEffectColorConfiguration';
+import RemoteEffectColorConfiguration from './RemoteEffectColorConfiguration';
+export * from './native';
+export * from './solid-effect';
+export * from './wave-effect';
+export * from './random-effect';
+export { EffectType, EffectConfiguration, EffectConfigurationBase, EffectColorType, EffectColorConfiguration, EffectColorConfigurationBase, ConstantEffectColorConfiguration, DynamicEffectColorConfiguration, RemoteEffectColorConfiguration, };

package/dist/types/effects/native/NativeDirection.d.ts

@@ -0,0 +1,7 @@
+declare enum NativeDirection {
+    Left = "left",
+    Right = "right",
+    Up = "up",
+    Down = "down"
+}
+export default NativeDirection;

package/dist/types/effects/native/NativeEffect.d.ts

@@ -0,0 +1,13 @@
+import NativeEffectColor from './NativeEffectColor';
+import NativeEffectOption from './NativeEffectOption';
+export default interface NativeEffect {
+    version: '2.0';
+    animName: string;
+    animType: 'plugin';
+    colorType: 'HSB';
+    palette: NativeEffectColor[];
+    pluginType: 'color';
+    pluginUuid: string;
+    pluginOptions: NativeEffectOption[];
+    hasOverlay: false;
+}

package/dist/types/effects/native/NativeEffectColor.d.ts

@@ -0,0 +1,6 @@
+export default interface NativeEffectColor {
+    hue: number;
+    saturation: number;
+    brightness: number;
+    probability: number;
+}

package/dist/types/effects/native/NativeEffectOption.d.ts

@@ -0,0 +1,18 @@
+import NativeDirection from './NativeDirection';
+type NativeEffectOption = {
+    name: 'delayTime';
+    value: number;
+} | {
+    name: 'transTime';
+    value: number;
+} | {
+    name: 'linDirection';
+    value: NativeDirection;
+} | {
+    name: 'loop';
+    value: boolean;
+} | {
+    name: 'nColorsPerFrame';
+    value: number;
+};
+export default NativeEffectOption;

package/dist/types/effects/native/NativeEffectType.d.ts

@@ -0,0 +1,9 @@
+declare enum NativeEffectType {
+    Wheel = "wheel",
+    Flow = "flow",
+    Explode = "explode",
+    Fade = "fade",
+    Random = "random",
+    Highlight = "highlight"
+}
+export default NativeEffectType;

package/dist/types/effects/native/index.d.ts

@@ -0,0 +1,6 @@
+import NativeDirection from './NativeDirection';
+import NativeEffect from './NativeEffect';
+import NativeEffectType from './NativeEffectType';
+import NativeEffectColor from './NativeEffectColor';
+import NativeEffectOption from './NativeEffectOption';
+export { NativeDirection, NativeEffect, NativeEffectType, NativeEffectColor, NativeEffectOption, };

package/dist/types/effects/random-effect/RandomEffectConfiguration.d.ts

@@ -0,0 +1,9 @@
+import EffectConfigurationBase from '../EffectConfigurationBase';
+import EffectType from '../EffectType';
+import EffectColorConfiguration from '../EffectColorConfiguration';
+export default interface RandomEffectConfiguration extends EffectConfigurationBase {
+    type: EffectType.Random;
+    delayTime: number;
+    transitionTime: number;
+    colors: EffectColorConfiguration[];
+}

package/dist/types/effects/random-effect/index.d.ts

@@ -0,0 +1,2 @@
+import RandomEffectConfiguration from './RandomEffectConfiguration';
+export { RandomEffectConfiguration };

package/dist/types/effects/solid-effect/SolidEffectColorConfiguration.d.ts

@@ -0,0 +1,4 @@
+import DynamicEffectColorConfiguration from '../DynamicEffectColorConfiguration';
+import RemoteEffectColorConfiguration from '../RemoteEffectColorConfiguration';
+type SolidEffectColorConfiguration = DynamicEffectColorConfiguration | RemoteEffectColorConfiguration;
+export default SolidEffectColorConfiguration;

package/dist/types/effects/solid-effect/SolidEffectConfiguration.d.ts

@@ -0,0 +1,7 @@
+import EffectConfigurationBase from '../EffectConfigurationBase';
+import EffectType from '../EffectType';
+import SolidEffectColorConfiguration from './SolidEffectColorConfiguration';
+export default interface SolidEffectConfiguration extends EffectConfigurationBase {
+    type: EffectType.Solid;
+    color: SolidEffectColorConfiguration;
+}

package/dist/types/effects/solid-effect/index.d.ts

@@ -0,0 +1,3 @@
+import SolidEffectConfiguration from './SolidEffectConfiguration';
+import SolidEffectColorConfiguration from './SolidEffectColorConfiguration';
+export { SolidEffectConfiguration, SolidEffectColorConfiguration };

package/dist/types/effects/wave-effect/WaveEffectConfiguration.d.ts

@@ -0,0 +1,11 @@
+import EffectConfigurationBase from '../EffectConfigurationBase';
+import EffectType from '../EffectType';
+import EffectColorConfiguration from '../EffectColorConfiguration';
+import { NativeDirection } from '../native';
+export default interface WaveEffectConfiguration extends EffectConfigurationBase {
+    type: EffectType.Wave;
+    direction: NativeDirection;
+    transitionTime: number;
+    colorSize: number;
+    colors: EffectColorConfiguration[];
+}

package/dist/types/effects/wave-effect/index.d.ts

@@ -0,0 +1,2 @@
+import WaveEffectConfiguration from './WaveEffectConfiguration';
+export { WaveEffectConfiguration };

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+import Context from './Context';
+import PlatformConfiguration from './PlatformConfiguration';
+export * from './devices';
+export * from './effects';
+export { Context, PlatformConfiguration };

package/dist/utilities/HomebridgeLogAppender.d.ts

@@ -0,0 +1,7 @@
+import { AbstractAppender, IEntry, STANDARD_LEVELS } from 'simple-node-logger';
+export default class HomebridgeLogAppender extends AbstractAppender {
+    private readonly homebridgeLog;
+    constructor(homebridgeLog: (message: string) => void);
+    write(entry: IEntry): void;
+    setLevel(level: STANDARD_LEVELS): void;
+}

package/dist/utilities/colorToNanoleafColor.d.ts

@@ -0,0 +1,4 @@
+import { Color } from '@manganese/palette-kit-core';
+import { NativeEffectColor } from '../types';
+declare const _default: (color: Color, probability?: number) => NativeEffectColor;
+export default _default;

package/dist/utilities/index.d.ts

@@ -0,0 +1,4 @@
+import HomebridgeLogAppender from './HomebridgeLogAppender';
+import colorToNanoleafColor from './colorToNanoleafColor';
+import nativeEffectTypeToPluginUuid from './nativeEffectTypeToPluginUuid';
+export { HomebridgeLogAppender, colorToNanoleafColor, nativeEffectTypeToPluginUuid, };

package/dist/utilities/nativeEffectTypeToPluginUuid.d.ts

@@ -0,0 +1,3 @@
+import { NativeEffectType } from '../types';
+declare const _default: (type: NativeEffectType) => string;
+export default _default;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "homebridge-nanoleaf-multi",
+  "description": "",
+  "homepage": "https://gitlab.com/5131/nanoleaf/homebridge-nanoleaf-multi#readme",
+  "keywords": [
+    "homebridge-plugin"
+  ],
+  "version": "1.0.0",
+  "deprecated": false,
+  "author": {
+    "name": "Samuel Goodell"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/5131/nanoleaf/homebridge-nanoleaf-multi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/5131/nanoleaf/homebridge-nanoleaf-multi.git"
+  },
+  "scripts": {
+    "clean": "rm -rf dist node_modules package-lock.json",
+    "build": "webpack",
+    "build:development": "NODE_ENV=development webpack",
+    "build:production": "NODE_ENV=production webpack"
+  },
+  "engines": {
+    "homebridge": ">=0.4.0",
+    "node": ">=8.0.0"
+  },
+  "main": "dist/index.js",
+  "dependencies": {
+    "@manganese/palette-kit-client": "^1.5",
+    "@manganese/palette-kit-core": "^1.5",
+    "async-lock": "^1.2.4",
+    "axios": "^0.19.2",
+    "colors": "^1.4.0",
+    "helpers-for-homebridge": "^2.0",
+    "nanoleaf-client-multi": "^1.0",
+    "rwlock": "^5.0.0",
+    "simple-node-logger": "^21.8.12"
+  },
+  "prettier": "@manganese/prettier-configuration",
+  "devDependencies": {
+    "@types/node": "^18.7.14",
+    "@babel/preset-env": "^7.18.10",
+    "@manganese/prettier-configuration": "^1.0",
+    "babel-loader": "^8.2.5",
+    "ts-loader": "^9.3.1",
+    "typescript": "^4.8.2",
+    "webpack-cli": "^4.10.0"
+  }
+}

package/src/Device.ts

@@ -0,0 +1,73 @@
+import { NanoleafClient } from 'nanoleaf-client-multi';
+import ReadWriteLock from 'rwlock';
+
+import { Context, DeviceConfiguration, NativeEffect } from './types';
+import { DEFAULT_DEVICE_SIZE } from './constants';
+import Effect from './Effect';
+
+export default class Device {
+  private initialized = false;
+  private nativeDevice: NanoleafClient;
+  private lock = new ReadWriteLock();
+
+  constructor(
+    private readonly configuration: DeviceConfiguration,
+    private readonly context: Context
+  ) {}
+
+  public get name() {
+    return this.configuration.name;
+  }
+
+  public get size() {
+    return this.configuration.size || DEFAULT_DEVICE_SIZE;
+  }
+
+  public async initialize() {
+    this.nativeDevice = new NanoleafClient(
+      this.configuration.ip,
+      this.configuration.token
+    );
+
+    const deviceInfo = await this.nativeDevice.getInfo();
+
+    this.context.log.info(`Initialized <${this.configuration.name}>`);
+    this.initialized = true;
+  }
+
+  private async withWriteLock(callback: () => Promise<void>) {
+    if (!this.initialized) {
+      return Promise.reject('Device is not initialized');
+    }
+
+    return await this.lock.writeLock(async (release) => {
+      try {
+        await callback();
+      } catch (error) {
+        this.context.log.debug('Error while holding write lock', error);
+      } finally {
+        release();
+      }
+    });
+  }
+
+  public async setActive(active: boolean) {
+    await this.withWriteLock(async () => {
+      await this.nativeDevice.power(active);
+    });
+  }
+
+  public async setActiveEffect(effect: Effect<any>) {
+    await this.withWriteLock(async () => {
+      const nativeEffect = effect.getNativeEffectForDevice(this);
+
+      await this.nativeDevice.addEffect(nativeEffect);
+    });
+  }
+
+  public async addNativeEffect(nativeEffect: NativeEffect) {
+    await this.withWriteLock(async () => {
+      await this.nativeDevice.addEffect(nativeEffect);
+    });
+  }
+}

package/src/Effect.ts

@@ -0,0 +1,80 @@
+import {
+  ColorHSV,
+  ColorType as CoreColorType,
+} from '@manganese/palette-kit-core';
+import { ClientColorType } from '@manganese/palette-kit-client';
+
+import EventEmitter from 'events';
+import {
+  Context,
+  EffectConfigurationBase,
+  NativeEffect,
+  ConstantEffectColorConfiguration,
+  DynamicEffectColorConfiguration,
+  RemoteEffectColorConfiguration,
+} from './types';
+import { DEFAULT_NATIVE_EFFECT_NAME, EFFECT_CHANGE_EVENT } from './constants';
+import Device from './Device';
+
+export default abstract class Effect<
+  EffectConfigurationType extends EffectConfigurationBase
+> extends EventEmitter {
+  protected enabled: boolean;
+
+  constructor(
+    protected readonly configuration: EffectConfigurationType,
+    protected readonly context: Context
+  ) {
+    super();
+  }
+
+  public async initialize() {}
+
+  public get id() {
+    return this.configuration.id;
+  }
+
+  public get name() {
+    return this.configuration.name;
+  }
+
+  protected get nativeEffectBase(): Partial<NativeEffect> {
+    return {
+      animName: this.configuration.nativeName || DEFAULT_NATIVE_EFFECT_NAME,
+    };
+  }
+
+  protected handleChange() {
+    this.emit(EFFECT_CHANGE_EVENT);
+  }
+
+  public abstract getNativeEffectForDevice(device: Device): NativeEffect;
+
+  public abstract getColors(): Array<
+    | ConstantEffectColorConfiguration
+    | DynamicEffectColorConfiguration
+    | RemoteEffectColorConfiguration
+  >;
+
+  public hasColor(colorId: string) {
+    return [...this.getDynamicColors(), ...this.getRemoteColors()].some(
+      (colorConfiguration) => {
+        return colorConfiguration.id === colorId;
+      }
+    );
+  }
+
+  public abstract setColor(colorId: string, color: ColorHSV);
+
+  public getDynamicColors(): DynamicEffectColorConfiguration[] {
+    return this.getColors().filter(
+      (colorConfiguration) => colorConfiguration.type === CoreColorType.Dynamic
+    ) as DynamicEffectColorConfiguration[];
+  }
+
+  public getRemoteColors(): RemoteEffectColorConfiguration[] {
+    return this.getColors().filter(
+      (colorConfiguration) => colorConfiguration.type === ClientColorType.Remote
+    ) as RemoteEffectColorConfiguration[];
+  }
+}

package/src/RandomEffect.ts

@@ -0,0 +1,82 @@
+import {
+  ColorHSV,
+  colorToColorHSV,
+  ColorType as CoreColorType,
+} from '@manganese/palette-kit-core';
+import { ClientColorType } from '@manganese/palette-kit-client';
+
+import {
+  Context,
+  RandomEffectConfiguration,
+  EffectColorConfiguration,
+  ConstantEffectColorConfiguration,
+  DynamicEffectColorConfiguration,
+  RemoteEffectColorConfiguration,
+  NativeEffectType,
+  NativeEffectOption,
+} from './types';
+import { NATIVE_EFFECT_BASE } from './constants';
+import {
+  colorToNanoleafColor,
+  nativeEffectTypeToPluginUuid,
+} from './utilities';
+import Effect from './Effect';
+import Device from './Device';
+
+export default class RandomEffect extends Effect<RandomEffectConfiguration> {
+  private colors = new Map<string /* color ID */, ColorHSV>();
+
+  constructor(configuration: RandomEffectConfiguration, context: Context) {
+    super(configuration, context);
+  }
+
+  public async initialize() {}
+
+  private getColor(colorConfiguration: EffectColorConfiguration) {
+    switch (colorConfiguration.type) {
+      case CoreColorType.Constant:
+        return (colorConfiguration as ConstantEffectColorConfiguration).color;
+      case CoreColorType.Dynamic:
+      case ClientColorType.Remote:
+        return this.colors.get(
+          (
+            colorConfiguration as
+              | DynamicEffectColorConfiguration
+              | RemoteEffectColorConfiguration
+          ).id
+        );
+    }
+  }
+
+  public getNativeEffectForDevice(_device: Device) {
+    return {
+      ...NATIVE_EFFECT_BASE,
+      ...this.nativeEffectBase,
+      pluginUuid: nativeEffectTypeToPluginUuid(NativeEffectType.Random),
+      pluginOptions: [
+        {
+          name: 'delayTime',
+          value: this.configuration.delayTime,
+        } as NativeEffectOption,
+        {
+          name: 'transTime',
+          value: this.configuration.transitionTime,
+        } as NativeEffectOption,
+      ],
+      palette: this.configuration.colors.map((colorConfiguration) => {
+        const color = this.getColor(colorConfiguration);
+
+        return colorToNanoleafColor(color, colorConfiguration.probability);
+      }),
+    };
+  }
+
+  public getColors() {
+    return this.configuration.colors;
+  }
+
+  public setColor(colorId: string, color: ColorHSV) {
+    this.colors.set(colorId, color);
+    this.handleChange();
+  }
+}

package/src/SolidEffect.ts

@@ -0,0 +1,38 @@
+import { ColorType, ColorHSV } from '@manganese/palette-kit-core';
+
+import {
+  Context,
+  DynamicEffectColorConfiguration,
+  SolidEffectConfiguration,
+} from './types';
+import { NATIVE_EFFECT_BASE } from './constants';
+import Effect from './Effect';
+import Device from './Device';
+
+const DEFAULT_COLOR_ID = 'default';
+
+export default class SolidEffect extends Effect<SolidEffectConfiguration> {
+  private color: ColorHSV;
+
+  constructor(configuration: SolidEffectConfiguration, context: Context) {
+    super(configuration, context);
+  }
+
+  public async initialize() {}
+
+  public getNativeEffectForDevice(_device: Device) {
+    return {
+      ...NATIVE_EFFECT_BASE,
+      ...this.nativeEffectBase,
+    };
+  }
+
+  public getColors() {
+    return [this.configuration.color];
+  }
+
+  public setColor(_colorId: string, color: ColorHSV) {
+    this.color = color;
+    this.handleChange();
+  }
+}