From 44c999437b3ee905585823fd942cb911c8a6b046 Mon Sep 17 00:00:00 2001 From: Ari Sosnovsky Date: Thu, 13 Nov 2025 16:16:38 -0500 Subject: [PATCH] refactor --- .direnv/bin/nix-direnv-reload | 19 + .../01x5k4nlxcpyd85nnr0b9gm89rm8ff4x-source | 1 + .../b14gvgfs5i16wq8h26grmxdxa62lnaa7-source | 1 + .../cjjpqrp9xy44j5fjh3mygyxy3i7mslj2-source | 1 + .../yj1wxm9hh8610iyzqnz75kvs6xl8j3my-source | 1 + ...e-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa | 1 + ...5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa.rc | 2133 +++++++++++++++++ .envrc | 6 + flake.lock | 61 + flake.nix | 2 +- lib.js | 737 ++++-- package-lock.json | 604 +++-- package.json | 4 +- src/ButtonController.ts | 194 -- src/HAmqtt.ts | 98 - src/IRController.ts | 176 -- src/button_controller/button_state_handler.ts | 118 + src/button_controller/entities.ts | 73 + src/button_controller/index.ts | 93 + src/button_controller/options.ts | 6 + src/button_controller/utils.ts | 17 + src/flicTypes.ts | 40 - src/ha_mqtt/index.ts | 109 + src/ha_mqtt/utils.ts | 9 + src/hub_controller/index.ts | 65 + src/hub_controller/utils.ts | 31 + src/hub_controller/virtual_device_update.ts | 60 + src/index.ts | 132 +- src/ir_controller/index.ts | 153 ++ src/ir_controller/utils.ts | 20 + src/mqtt.ts | 902 +++---- tsconfig.json | 15 +- types/flic.sdk.buttons.d.ts | 118 + types/flic.sdk.flicapp.d.ts | 84 + types/flic.sdk.hubinfo.d.ts | 8 + types/flic.sdk.irmodule.d.ts | 22 + types/ha.types.d.ts | 25 + types/options.types.d.ts | 39 + 38 files changed, 4752 insertions(+), 1426 deletions(-) create mode 100755 .direnv/bin/nix-direnv-reload create mode 120000 .direnv/flake-inputs/01x5k4nlxcpyd85nnr0b9gm89rm8ff4x-source create mode 120000 .direnv/flake-inputs/b14gvgfs5i16wq8h26grmxdxa62lnaa7-source create mode 120000 .direnv/flake-inputs/cjjpqrp9xy44j5fjh3mygyxy3i7mslj2-source create mode 120000 .direnv/flake-inputs/yj1wxm9hh8610iyzqnz75kvs6xl8j3my-source create mode 120000 .direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa create mode 100644 .direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa.rc create mode 100644 .envrc create mode 100644 flake.lock delete mode 100644 src/ButtonController.ts delete mode 100644 src/HAmqtt.ts delete mode 100644 src/IRController.ts create mode 100644 src/button_controller/button_state_handler.ts create mode 100644 src/button_controller/entities.ts create mode 100644 src/button_controller/index.ts create mode 100644 src/button_controller/options.ts create mode 100644 src/button_controller/utils.ts delete mode 100644 src/flicTypes.ts create mode 100644 src/ha_mqtt/index.ts create mode 100644 src/ha_mqtt/utils.ts create mode 100644 src/hub_controller/index.ts create mode 100644 src/hub_controller/utils.ts create mode 100644 src/hub_controller/virtual_device_update.ts create mode 100644 src/ir_controller/index.ts create mode 100644 src/ir_controller/utils.ts create mode 100644 types/flic.sdk.buttons.d.ts create mode 100644 types/flic.sdk.flicapp.d.ts create mode 100644 types/flic.sdk.hubinfo.d.ts create mode 100644 types/flic.sdk.irmodule.d.ts create mode 100644 types/ha.types.d.ts create mode 100644 types/options.types.d.ts diff --git a/.direnv/bin/nix-direnv-reload b/.direnv/bin/nix-direnv-reload new file mode 100755 index 0000000..bf5b9d8 --- /dev/null +++ b/.direnv/bin/nix-direnv-reload @@ -0,0 +1,19 @@ +#!/usr/bin/env bash +set -e +if [[ ! -d "/mnt/Data/Projects/flic2hass" ]]; then + echo "Cannot find source directory; Did you move it?" + echo "(Looking for "/mnt/Data/Projects/flic2hass")" + echo 'Cannot force reload with this script - use "direnv reload" manually and then try again' + exit 1 +fi + +# rebuild the cache forcefully +_nix_direnv_force_reload=1 direnv exec "/mnt/Data/Projects/flic2hass" true + +# Update the mtime for .envrc. +# This will cause direnv to reload again - but without re-building. +touch "/mnt/Data/Projects/flic2hass/.envrc" + +# Also update the timestamp of whatever profile_rc we have. +# This makes sure that we know we are up to date. +touch -r "/mnt/Data/Projects/flic2hass/.envrc" "/mnt/Data/Projects/flic2hass/.direnv"/*.rc diff --git a/.direnv/flake-inputs/01x5k4nlxcpyd85nnr0b9gm89rm8ff4x-source b/.direnv/flake-inputs/01x5k4nlxcpyd85nnr0b9gm89rm8ff4x-source new file mode 120000 index 0000000..f7fce9f --- /dev/null +++ b/.direnv/flake-inputs/01x5k4nlxcpyd85nnr0b9gm89rm8ff4x-source @@ -0,0 +1 @@ +/nix/store/01x5k4nlxcpyd85nnr0b9gm89rm8ff4x-source \ No newline at end of file diff --git a/.direnv/flake-inputs/b14gvgfs5i16wq8h26grmxdxa62lnaa7-source b/.direnv/flake-inputs/b14gvgfs5i16wq8h26grmxdxa62lnaa7-source new file mode 120000 index 0000000..f3d4927 --- /dev/null +++ b/.direnv/flake-inputs/b14gvgfs5i16wq8h26grmxdxa62lnaa7-source @@ -0,0 +1 @@ +/nix/store/b14gvgfs5i16wq8h26grmxdxa62lnaa7-source \ No newline at end of file diff --git a/.direnv/flake-inputs/cjjpqrp9xy44j5fjh3mygyxy3i7mslj2-source b/.direnv/flake-inputs/cjjpqrp9xy44j5fjh3mygyxy3i7mslj2-source new file mode 120000 index 0000000..aa534df --- /dev/null +++ b/.direnv/flake-inputs/cjjpqrp9xy44j5fjh3mygyxy3i7mslj2-source @@ -0,0 +1 @@ +/nix/store/cjjpqrp9xy44j5fjh3mygyxy3i7mslj2-source \ No newline at end of file diff --git a/.direnv/flake-inputs/yj1wxm9hh8610iyzqnz75kvs6xl8j3my-source b/.direnv/flake-inputs/yj1wxm9hh8610iyzqnz75kvs6xl8j3my-source new file mode 120000 index 0000000..f17959f --- /dev/null +++ b/.direnv/flake-inputs/yj1wxm9hh8610iyzqnz75kvs6xl8j3my-source @@ -0,0 +1 @@ +/nix/store/yj1wxm9hh8610iyzqnz75kvs6xl8j3my-source \ No newline at end of file diff --git a/.direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa b/.direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa new file mode 120000 index 0000000..3f4fa05 --- /dev/null +++ b/.direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa @@ -0,0 +1 @@ +/nix/store/45gfi0xqahibazd3mwkcbxx18slzjcv7-nix-shell-env \ No newline at end of file diff --git a/.direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa.rc b/.direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa.rc new file mode 100644 index 0000000..e94656c --- /dev/null +++ b/.direnv/flake-profile-a5d5b61aa8a61b7d9d765e1daf971a9a578f1cfa.rc @@ -0,0 +1,2133 @@ +unset shellHook +PATH=${PATH:-} +nix_saved_PATH="$PATH" +XDG_DATA_DIRS=${XDG_DATA_DIRS:-} +nix_saved_XDG_DATA_DIRS="$XDG_DATA_DIRS" +AR='ar' +export AR +AS='as' +export AS +BASH='/nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3/bin/bash' +CC='gcc' +export CC +CONFIG_SHELL='/nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3/bin/bash' +export CONFIG_SHELL +CXX='g++' +export CXX +HOSTTYPE='x86_64' +HOST_PATH='/nix/store/519i2gakc2mlh499s7ngggvnms48an1x-nodejs-20.19.5-dev/bin:/nix/store/jh5j35wpkxlznmzq68c07ajq7wk08s6v-nodejs-20.19.5/bin:/nix/store/xs8scz9w9jp4hpqycx3n3bah5y07ymgj-coreutils-9.8/bin:/nix/store/qqvfnxa9jg71wp4hfg1l63r4m78iwvl9-findutils-4.10.0/bin:/nix/store/7ql4x9i7w7ihxw23vkanvcvrvqhay23c-diffutils-3.12/bin:/nix/store/zppkx0lkizglyqa9h26wf495qkllrjgy-gnused-4.9/bin:/nix/store/22r4s6lqhl43jkazn51f3c18qwk894g4-gnugrep-3.12/bin:/nix/store/8c4l9cqqj7pixqlmljx5d495pfpw8pys-gawk-5.3.2/bin:/nix/store/3m0zcl1by8ifylmgdcaa317cnhqn8q95-gnutar-1.35/bin:/nix/store/vjj9x3dzszbzjpkzwx63z4gpypiqphzf-gzip-1.14/bin:/nix/store/vzj5iy2png2rs6q2kb3svzp0cnd878f1-bzip2-1.0.8-bin/bin:/nix/store/43lv2nr7pj7wy09qyicjq57bl209ccis-gnumake-4.4.1/bin:/nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3/bin:/nix/store/miap8jjp87z0gibkrzh68lw2w8kzy4yx-patch-2.8/bin:/nix/store/vwx988887gsrdvg9lbg5f03sy91wrjjv-xz-5.8.1-bin/bin:/nix/store/n686xm9c2ak4x02pj9izvkm0zx7ilwir-file-5.45/bin' +export HOST_PATH +IFS=' +' +IN_NIX_SHELL='impure' +export IN_NIX_SHELL +LD='ld' +export LD +LINENO='80' +MACHTYPE='x86_64-pc-linux-gnu' +NIX_BINTOOLS='/nix/store/918ldr9axgh5kdmpp5fnj2n37pyghwbx-binutils-wrapper-2.44' +export NIX_BINTOOLS +NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu='1' +export NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu +NIX_BUILD_CORES='12' +export NIX_BUILD_CORES +NIX_CC='/nix/store/x8mydcgbry214s802nzvy7fdljx404ym-gcc-wrapper-14.3.0' +export NIX_CC +NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu='1' +export NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu +NIX_CFLAGS_COMPILE=' -frandom-seed=45gfi0xqah -isystem /nix/store/519i2gakc2mlh499s7ngggvnms48an1x-nodejs-20.19.5-dev/include -isystem /nix/store/jh5j35wpkxlznmzq68c07ajq7wk08s6v-nodejs-20.19.5/include -isystem /nix/store/519i2gakc2mlh499s7ngggvnms48an1x-nodejs-20.19.5-dev/include -isystem /nix/store/jh5j35wpkxlznmzq68c07ajq7wk08s6v-nodejs-20.19.5/include' +export NIX_CFLAGS_COMPILE +NIX_ENFORCE_NO_NATIVE='1' +export NIX_ENFORCE_NO_NATIVE +NIX_HARDENING_ENABLE='bindnow format fortify fortify3 pic relro stackclashprotection stackprotector strictoverflow zerocallusedregs' +export NIX_HARDENING_ENABLE +NIX_LDFLAGS='-rpath /mnt/Data/Projects/flic2hass/outputs/out/lib ' +export NIX_LDFLAGS +NIX_NO_SELF_RPATH='1' +NIX_STORE='/nix/store' +export NIX_STORE +NM='nm' +export NM +NODE_PATH='/nix/store/jh5j35wpkxlznmzq68c07ajq7wk08s6v-nodejs-20.19.5/lib/node_modules' +export NODE_PATH +OBJCOPY='objcopy' +export OBJCOPY +OBJDUMP='objdump' +export OBJDUMP +OLDPWD='' +export OLDPWD +OPTERR='1' +OSTYPE='linux-gnu' +PATH='/nix/store/85n78yrssyfc65f32yxpqqcpzkgbjv8c-patchelf-0.15.2/bin:/nix/store/x8mydcgbry214s802nzvy7fdljx404ym-gcc-wrapper-14.3.0/bin:/nix/store/ffrg0560kj0066s4k9pznjand907nlnz-gcc-14.3.0/bin:/nix/store/76zn66xib0r80s5y7p0m1ba3y036sxwh-glibc-2.40-66-bin/bin:/nix/store/xs8scz9w9jp4hpqycx3n3bah5y07ymgj-coreutils-9.8/bin:/nix/store/918ldr9axgh5kdmpp5fnj2n37pyghwbx-binutils-wrapper-2.44/bin:/nix/store/416ykpc2bksb90sd1ia8cybxb3p83mrd-binutils-2.44/bin:/nix/store/519i2gakc2mlh499s7ngggvnms48an1x-nodejs-20.19.5-dev/bin:/nix/store/jh5j35wpkxlznmzq68c07ajq7wk08s6v-nodejs-20.19.5/bin:/nix/store/xs8scz9w9jp4hpqycx3n3bah5y07ymgj-coreutils-9.8/bin:/nix/store/qqvfnxa9jg71wp4hfg1l63r4m78iwvl9-findutils-4.10.0/bin:/nix/store/7ql4x9i7w7ihxw23vkanvcvrvqhay23c-diffutils-3.12/bin:/nix/store/zppkx0lkizglyqa9h26wf495qkllrjgy-gnused-4.9/bin:/nix/store/22r4s6lqhl43jkazn51f3c18qwk894g4-gnugrep-3.12/bin:/nix/store/8c4l9cqqj7pixqlmljx5d495pfpw8pys-gawk-5.3.2/bin:/nix/store/3m0zcl1by8ifylmgdcaa317cnhqn8q95-gnutar-1.35/bin:/nix/store/vjj9x3dzszbzjpkzwx63z4gpypiqphzf-gzip-1.14/bin:/nix/store/vzj5iy2png2rs6q2kb3svzp0cnd878f1-bzip2-1.0.8-bin/bin:/nix/store/43lv2nr7pj7wy09qyicjq57bl209ccis-gnumake-4.4.1/bin:/nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3/bin:/nix/store/miap8jjp87z0gibkrzh68lw2w8kzy4yx-patch-2.8/bin:/nix/store/vwx988887gsrdvg9lbg5f03sy91wrjjv-xz-5.8.1-bin/bin:/nix/store/n686xm9c2ak4x02pj9izvkm0zx7ilwir-file-5.45/bin' +export PATH +PS4='+ ' +RANLIB='ranlib' +export RANLIB +READELF='readelf' +export READELF +SHELL='/nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3/bin/bash' +export SHELL +SIZE='size' +export SIZE +SOURCE_DATE_EPOCH='315532800' +export SOURCE_DATE_EPOCH +STRINGS='strings' +export STRINGS +STRIP='strip' +export STRIP +XDG_DATA_DIRS='/nix/store/85n78yrssyfc65f32yxpqqcpzkgbjv8c-patchelf-0.15.2/share' +export XDG_DATA_DIRS +__structuredAttrs='' +export __structuredAttrs +_substituteStream_has_warned_replace_deprecation='false' +buildInputs='/nix/store/519i2gakc2mlh499s7ngggvnms48an1x-nodejs-20.19.5-dev' +export buildInputs +buildPhase='{ echo "------------------------------------------------------------"; + echo " WARNING: the existence of this path is not guaranteed."; + echo " It is an internal implementation detail for pkgs.mkShell."; + echo "------------------------------------------------------------"; + echo; + # Record all build inputs as runtime dependencies + export; +} >> "$out" +' +export buildPhase +builder='/nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3/bin/bash' +export builder +cmakeFlags='' +export cmakeFlags +configureFlags='' +export configureFlags +defaultBuildInputs='' +defaultNativeBuildInputs='/nix/store/85n78yrssyfc65f32yxpqqcpzkgbjv8c-patchelf-0.15.2 /nix/store/lbfg38p9kgm2dadwjqa7fgv0sjjh3ban-update-autotools-gnu-config-scripts-hook /nix/store/0y5xmdb7qfvimjwbq7ibg1xdgkgjwqng-no-broken-symlinks.sh /nix/store/cv1d7p48379km6a85h4zp6kr86brh32q-audit-tmpdir.sh /nix/store/85clx3b0xkdf58jn161iy80y5223ilbi-compress-man-pages.sh /nix/store/wgrbkkaldkrlrni33ccvm3b6vbxzb656-make-symlinks-relative.sh /nix/store/5yzw0vhkyszf2d179m0qfkgxmp5wjjx4-move-docs.sh /nix/store/fyaryjvghbkpfnsyw97hb3lyb37s1pd6-move-lib64.sh /nix/store/kd4xwxjpjxi71jkm6ka0np72if9rm3y0-move-sbin.sh /nix/store/pag6l61paj1dc9sv15l7bm5c17xn5kyk-move-systemd-user-units.sh /nix/store/cmzya9irvxzlkh7lfy6i82gbp0saxqj3-multiple-outputs.sh /nix/store/x8c40nfigps493a07sdr2pm5s9j1cdc0-patch-shebangs.sh /nix/store/cickvswrvann041nqxb0rxilc46svw1n-prune-libtool-files.sh /nix/store/xyff06pkhki3qy1ls77w10s0v79c9il0-reproducible-builds.sh /nix/store/z7k98578dfzi6l3hsvbivzm7hfqlk0zc-set-source-date-epoch-to-latest.sh /nix/store/pilsssjjdxvdphlg2h19p0bfx5q0jzkn-strip.sh /nix/store/x8mydcgbry214s802nzvy7fdljx404ym-gcc-wrapper-14.3.0' +depsBuildBuild='' +export depsBuildBuild +depsBuildBuildPropagated='' +export depsBuildBuildPropagated +depsBuildTarget='' +export depsBuildTarget +depsBuildTargetPropagated='' +export depsBuildTargetPropagated +depsHostHost='' +export depsHostHost +depsHostHostPropagated='' +export depsHostHostPropagated +depsTargetTarget='' +export depsTargetTarget +depsTargetTargetPropagated='' +export depsTargetTargetPropagated +doCheck='' +export doCheck +doInstallCheck='' +export doInstallCheck +dontAddDisableDepTrack='1' +export dontAddDisableDepTrack +declare -a envBuildBuildHooks=() +declare -a envBuildHostHooks=() +declare -a envBuildTargetHooks=() +declare -a envHostHostHooks=('ccWrapper_addCVars' 'bintoolsWrapper_addLDVars' 'addNodePath' ) +declare -a envHostTargetHooks=('ccWrapper_addCVars' 'bintoolsWrapper_addLDVars' 'addNodePath' ) +declare -a envTargetTargetHooks=() +declare -a fixupOutputHooks=('if [ -z "${dontPatchELF-}" ]; then patchELF "$prefix"; fi' 'if [[ -z "${noAuditTmpdir-}" && -e "$prefix" ]]; then auditTmpdir "$prefix"; fi' 'if [ -z "${dontGzipMan-}" ]; then compressManPages "$prefix"; fi' '_moveLib64' '_moveSbin' '_moveSystemdUserUnits' 'patchShebangsAuto' '_pruneLibtoolFiles' '_doStrip' ) +initialPath='/nix/store/xs8scz9w9jp4hpqycx3n3bah5y07ymgj-coreutils-9.8 /nix/store/qqvfnxa9jg71wp4hfg1l63r4m78iwvl9-findutils-4.10.0 /nix/store/7ql4x9i7w7ihxw23vkanvcvrvqhay23c-diffutils-3.12 /nix/store/zppkx0lkizglyqa9h26wf495qkllrjgy-gnused-4.9 /nix/store/22r4s6lqhl43jkazn51f3c18qwk894g4-gnugrep-3.12 /nix/store/8c4l9cqqj7pixqlmljx5d495pfpw8pys-gawk-5.3.2 /nix/store/3m0zcl1by8ifylmgdcaa317cnhqn8q95-gnutar-1.35 /nix/store/vjj9x3dzszbzjpkzwx63z4gpypiqphzf-gzip-1.14 /nix/store/vzj5iy2png2rs6q2kb3svzp0cnd878f1-bzip2-1.0.8-bin /nix/store/43lv2nr7pj7wy09qyicjq57bl209ccis-gnumake-4.4.1 /nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3 /nix/store/miap8jjp87z0gibkrzh68lw2w8kzy4yx-patch-2.8 /nix/store/vwx988887gsrdvg9lbg5f03sy91wrjjv-xz-5.8.1-bin /nix/store/n686xm9c2ak4x02pj9izvkm0zx7ilwir-file-5.45' +mesonFlags='' +export mesonFlags +name='nix-shell-env' +export name +nativeBuildInputs='' +export nativeBuildInputs +out='/mnt/Data/Projects/flic2hass/outputs/out' +export out +outputBin='out' +outputDev='out' +outputDevdoc='REMOVE' +outputDevman='out' +outputDoc='out' +outputInclude='out' +outputInfo='out' +outputLib='out' +outputMan='out' +outputs='out' +export outputs +patches='' +export patches +phases='buildPhase' +export phases +pkg='/nix/store/x8mydcgbry214s802nzvy7fdljx404ym-gcc-wrapper-14.3.0' +declare -a pkgsBuildBuild=() +declare -a pkgsBuildHost=('/nix/store/85n78yrssyfc65f32yxpqqcpzkgbjv8c-patchelf-0.15.2' '/nix/store/lbfg38p9kgm2dadwjqa7fgv0sjjh3ban-update-autotools-gnu-config-scripts-hook' '/nix/store/0y5xmdb7qfvimjwbq7ibg1xdgkgjwqng-no-broken-symlinks.sh' '/nix/store/cv1d7p48379km6a85h4zp6kr86brh32q-audit-tmpdir.sh' '/nix/store/85clx3b0xkdf58jn161iy80y5223ilbi-compress-man-pages.sh' '/nix/store/wgrbkkaldkrlrni33ccvm3b6vbxzb656-make-symlinks-relative.sh' '/nix/store/5yzw0vhkyszf2d179m0qfkgxmp5wjjx4-move-docs.sh' '/nix/store/fyaryjvghbkpfnsyw97hb3lyb37s1pd6-move-lib64.sh' '/nix/store/kd4xwxjpjxi71jkm6ka0np72if9rm3y0-move-sbin.sh' '/nix/store/pag6l61paj1dc9sv15l7bm5c17xn5kyk-move-systemd-user-units.sh' '/nix/store/cmzya9irvxzlkh7lfy6i82gbp0saxqj3-multiple-outputs.sh' '/nix/store/x8c40nfigps493a07sdr2pm5s9j1cdc0-patch-shebangs.sh' '/nix/store/cickvswrvann041nqxb0rxilc46svw1n-prune-libtool-files.sh' '/nix/store/xyff06pkhki3qy1ls77w10s0v79c9il0-reproducible-builds.sh' '/nix/store/z7k98578dfzi6l3hsvbivzm7hfqlk0zc-set-source-date-epoch-to-latest.sh' '/nix/store/pilsssjjdxvdphlg2h19p0bfx5q0jzkn-strip.sh' '/nix/store/x8mydcgbry214s802nzvy7fdljx404ym-gcc-wrapper-14.3.0' '/nix/store/918ldr9axgh5kdmpp5fnj2n37pyghwbx-binutils-wrapper-2.44' ) +declare -a pkgsBuildTarget=() +declare -a pkgsHostHost=() +declare -a pkgsHostTarget=('/nix/store/519i2gakc2mlh499s7ngggvnms48an1x-nodejs-20.19.5-dev' '/nix/store/jh5j35wpkxlznmzq68c07ajq7wk08s6v-nodejs-20.19.5' ) +declare -a pkgsTargetTarget=() +declare -a postFixupHooks=('noBrokenSymlinksInAllOutputs' '_makeSymlinksRelativeInAllOutputs' '_multioutPropagateDev' ) +declare -a postUnpackHooks=('_updateSourceDateEpochFromSourceRoot' ) +declare -a preConfigureHooks=('_multioutConfig' ) +preConfigurePhases=' updateAutotoolsGnuConfigScriptsPhase' +declare -a preFixupHooks=('_moveToShare' '_multioutDocs' '_multioutDevs' ) +preferLocalBuild='1' +export preferLocalBuild +prefix='/mnt/Data/Projects/flic2hass/outputs/out' +declare -a propagatedBuildDepFiles=('propagated-build-build-deps' 'propagated-native-build-inputs' 'propagated-build-target-deps' ) +propagatedBuildInputs='' +export propagatedBuildInputs +declare -a propagatedHostDepFiles=('propagated-host-host-deps' 'propagated-build-inputs' ) +propagatedNativeBuildInputs='' +export propagatedNativeBuildInputs +declare -a propagatedTargetDepFiles=('propagated-target-target-deps' ) +shell='/nix/store/ciarnmsx8lvsrmdbjddpmx0pqjrm8imb-bash-5.3p3/bin/bash' +export shell +shellHook='echo "TypeScript dev environment loaded" +echo "Node.js: $(node --version)" +' +export shellHook +stdenv='/nix/store/jsj1sql9id9c10sxmg7rvq3pj0f1l19b-stdenv-linux' +export stdenv +strictDeps='' +export strictDeps +system='x86_64-linux' +export system +declare -a unpackCmdHooks=('_defaultUnpack' ) +_activatePkgs () +{ + + local hostOffset targetOffset; + local pkg; + for hostOffset in "${allPlatOffsets[@]}"; + do + local pkgsVar="${pkgAccumVarVars[hostOffset + 1]}"; + for targetOffset in "${allPlatOffsets[@]}"; + do + (( hostOffset <= targetOffset )) || continue; + local pkgsRef="${pkgsVar}[$targetOffset - $hostOffset]"; + local pkgsSlice="${!pkgsRef}[@]"; + for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; + do + activatePackage "$pkg" "$hostOffset" "$targetOffset"; + done; + done; + done +} +_addRpathPrefix () +{ + + if [ "${NIX_NO_SELF_RPATH:-0}" != 1 ]; then + export NIX_LDFLAGS="-rpath $1/lib ${NIX_LDFLAGS-}"; + fi +} +_addToEnv () +{ + + local depHostOffset depTargetOffset; + local pkg; + for depHostOffset in "${allPlatOffsets[@]}"; + do + local hookVar="${pkgHookVarVars[depHostOffset + 1]}"; + local pkgsVar="${pkgAccumVarVars[depHostOffset + 1]}"; + for depTargetOffset in "${allPlatOffsets[@]}"; + do + (( depHostOffset <= depTargetOffset )) || continue; + local hookRef="${hookVar}[$depTargetOffset - $depHostOffset]"; + if [[ -z "${strictDeps-}" ]]; then + local visitedPkgs=""; + for pkg in "${pkgsBuildBuild[@]}" "${pkgsBuildHost[@]}" "${pkgsBuildTarget[@]}" "${pkgsHostHost[@]}" "${pkgsHostTarget[@]}" "${pkgsTargetTarget[@]}"; + do + if [[ "$visitedPkgs" = *"$pkg"* ]]; then + continue; + fi; + runHook "${!hookRef}" "$pkg"; + visitedPkgs+=" $pkg"; + done; + else + local pkgsRef="${pkgsVar}[$depTargetOffset - $depHostOffset]"; + local pkgsSlice="${!pkgsRef}[@]"; + for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; + do + runHook "${!hookRef}" "$pkg"; + done; + fi; + done; + done +} +_allFlags () +{ + + export system pname name version; + while IFS='' read -r varName; do + nixTalkativeLog "@${varName}@ -> ${!varName}"; + args+=("--subst-var" "$varName"); + done < <(awk 'BEGIN { for (v in ENVIRON) if (v ~ /^[a-z][a-zA-Z0-9_]*$/) print v }') +} +_assignFirst () +{ + + local varName="$1"; + local _var; + local REMOVE=REMOVE; + shift; + for _var in "$@"; + do + if [ -n "${!_var-}" ]; then + eval "${varName}"="${_var}"; + return; + fi; + done; + echo; + echo "error: _assignFirst: could not find a non-empty variable whose name to assign to ${varName}."; + echo " The following variables were all unset or empty:"; + echo " $*"; + if [ -z "${out:-}" ]; then + echo ' If you do not want an "out" output in your derivation, make sure to define'; + echo ' the other specific required outputs. This can be achieved by picking one'; + echo " of the above as an output."; + echo ' You do not have to remove "out" if you want to have a different default'; + echo ' output, because the first output is taken as a default.'; + echo; + fi; + return 1 +} +_callImplicitHook () +{ + + local def="$1"; + local hookName="$2"; + if declare -F "$hookName" > /dev/null; then + nixTalkativeLog "calling implicit '$hookName' function hook"; + "$hookName"; + else + if type -p "$hookName" > /dev/null; then + nixTalkativeLog "sourcing implicit '$hookName' script hook"; + source "$hookName"; + else + if [ -n "${!hookName:-}" ]; then + nixTalkativeLog "evaling implicit '$hookName' string hook"; + eval "${!hookName}"; + else + return "$def"; + fi; + fi; + fi +} +_defaultUnpack () +{ + + local fn="$1"; + local destination; + if [ -d "$fn" ]; then + destination="$(stripHash "$fn")"; + if [ -e "$destination" ]; then + echo "Cannot copy $fn to $destination: destination already exists!"; + echo "Did you specify two \"srcs\" with the same \"name\"?"; + return 1; + fi; + cp -r --preserve=timestamps --reflink=auto -- "$fn" "$destination"; + else + case "$fn" in + *.tar.xz | *.tar.lzma | *.txz) + ( XZ_OPT="--threads=$NIX_BUILD_CORES" xz -d < "$fn"; + true ) | tar xf - --mode=+w --warning=no-timestamp + ;; + *.tar | *.tar.* | *.tgz | *.tbz2 | *.tbz) + tar xf "$fn" --mode=+w --warning=no-timestamp + ;; + *) + return 1 + ;; + esac; + fi +} +_doStrip () +{ + + local -ra flags=(dontStripHost dontStripTarget); + local -ra debugDirs=(stripDebugList stripDebugListTarget); + local -ra allDirs=(stripAllList stripAllListTarget); + local -ra stripCmds=(STRIP STRIP_FOR_TARGET); + local -ra ranlibCmds=(RANLIB RANLIB_FOR_TARGET); + stripDebugList=${stripDebugList[*]:-lib lib32 lib64 libexec bin sbin Applications Library/Frameworks}; + stripDebugListTarget=${stripDebugListTarget[*]:-}; + stripAllList=${stripAllList[*]:-}; + stripAllListTarget=${stripAllListTarget[*]:-}; + local i; + for i in ${!stripCmds[@]}; + do + local -n flag="${flags[$i]}"; + local -n debugDirList="${debugDirs[$i]}"; + local -n allDirList="${allDirs[$i]}"; + local -n stripCmd="${stripCmds[$i]}"; + local -n ranlibCmd="${ranlibCmds[$i]}"; + if [[ -n "${dontStrip-}" || -n "${flag-}" ]] || ! type -f "${stripCmd-}" 2> /dev/null 1>&2; then + continue; + fi; + stripDirs "$stripCmd" "$ranlibCmd" "$debugDirList" "${stripDebugFlags[*]:--S -p}"; + stripDirs "$stripCmd" "$ranlibCmd" "$allDirList" "${stripAllFlags[*]:--s -p}"; + done +} +_eval () +{ + + if declare -F "$1" > /dev/null 2>&1; then + "$@"; + else + eval "$1"; + fi +} +_logHook () +{ + + if [[ -z ${NIX_LOG_FD-} ]]; then + return; + fi; + local hookKind="$1"; + local hookExpr="$2"; + shift 2; + if declare -F "$hookExpr" > /dev/null 2>&1; then + nixTalkativeLog "calling '$hookKind' function hook '$hookExpr'" "$@"; + else + if type -p "$hookExpr" > /dev/null; then + nixTalkativeLog "sourcing '$hookKind' script hook '$hookExpr'"; + else + if [[ "$hookExpr" != "_callImplicitHook"* ]]; then + local exprToOutput; + if [[ ${NIX_DEBUG:-0} -ge 5 ]]; then + exprToOutput="$hookExpr"; + else + local hookExprLine; + while IFS= read -r hookExprLine; do + hookExprLine="${hookExprLine#"${hookExprLine%%[![:space:]]*}"}"; + if [[ -n "$hookExprLine" ]]; then + exprToOutput+="$hookExprLine\\n "; + fi; + done <<< "$hookExpr"; + exprToOutput="${exprToOutput%%\\n }"; + fi; + nixTalkativeLog "evaling '$hookKind' string hook '$exprToOutput'"; + fi; + fi; + fi +} +_makeSymlinksRelative () +{ + + local symlinkTarget; + if [ "${dontRewriteSymlinks-}" ] || [ ! -e "$prefix" ]; then + return; + fi; + while IFS= read -r -d '' f; do + symlinkTarget=$(readlink "$f"); + if [[ "$symlinkTarget"/ != "$prefix"/* ]]; then + continue; + fi; + if [ ! -e "$symlinkTarget" ]; then + echo "the symlink $f is broken, it points to $symlinkTarget (which is missing)"; + fi; + echo "rewriting symlink $f to be relative to $prefix"; + ln -snrf "$symlinkTarget" "$f"; + done < <(find $prefix -type l -print0) +} +_makeSymlinksRelativeInAllOutputs () +{ + + local output; + for output in $(getAllOutputNames); + do + prefix="${!output}" _makeSymlinksRelative; + done +} +_moveLib64 () +{ + + if [ "${dontMoveLib64-}" = 1 ]; then + return; + fi; + if [ ! -e "$prefix/lib64" -o -L "$prefix/lib64" ]; then + return; + fi; + echo "moving $prefix/lib64/* to $prefix/lib"; + mkdir -p $prefix/lib; + shopt -s dotglob; + for i in $prefix/lib64/*; + do + mv --no-clobber "$i" $prefix/lib; + done; + shopt -u dotglob; + rmdir $prefix/lib64; + ln -s lib $prefix/lib64 +} +_moveSbin () +{ + + if [ "${dontMoveSbin-}" = 1 ]; then + return; + fi; + if [ ! -e "$prefix/sbin" -o -L "$prefix/sbin" ]; then + return; + fi; + echo "moving $prefix/sbin/* to $prefix/bin"; + mkdir -p $prefix/bin; + shopt -s dotglob; + for i in $prefix/sbin/*; + do + mv "$i" $prefix/bin; + done; + shopt -u dotglob; + rmdir $prefix/sbin; + ln -s bin $prefix/sbin +} +_moveSystemdUserUnits () +{ + + if [ "${dontMoveSystemdUserUnits:-0}" = 1 ]; then + return; + fi; + if [ ! -e "${prefix:?}/lib/systemd/user" ]; then + return; + fi; + local source="$prefix/lib/systemd/user"; + local target="$prefix/share/systemd/user"; + echo "moving $source/* to $target"; + mkdir -p "$target"; + ( shopt -s dotglob; + for i in "$source"/*; + do + mv "$i" "$target"; + done ); + rmdir "$source"; + ln -s "$target" "$source" +} +_moveToShare () +{ + + if [ -n "$__structuredAttrs" ]; then + if [ -z "${forceShare-}" ]; then + forceShare=(man doc info); + fi; + else + forceShare=(${forceShare:-man doc info}); + fi; + if [[ -z "$out" ]]; then + return; + fi; + for d in "${forceShare[@]}"; + do + if [ -d "$out/$d" ]; then + if [ -d "$out/share/$d" ]; then + echo "both $d/ and share/$d/ exist!"; + else + echo "moving $out/$d to $out/share/$d"; + mkdir -p $out/share; + mv $out/$d $out/share/; + fi; + fi; + done +} +_multioutConfig () +{ + + if [ "$(getAllOutputNames)" = "out" ] || [ -z "${setOutputFlags-1}" ]; then + return; + fi; + if [ -z "${shareDocName:-}" ]; then + local confScript="${configureScript:-}"; + if [ -z "$confScript" ] && [ -x ./configure ]; then + confScript=./configure; + fi; + if [ -f "$confScript" ]; then + local shareDocName="$(sed -n "s/^PACKAGE_TARNAME='\(.*\)'$/\1/p" < "$confScript")"; + fi; + if [ -z "$shareDocName" ] || echo "$shareDocName" | grep -q '[^a-zA-Z0-9_-]'; then + shareDocName="$(echo "$name" | sed 's/-[^a-zA-Z].*//')"; + fi; + fi; + prependToVar configureFlags --bindir="${!outputBin}"/bin --sbindir="${!outputBin}"/sbin --includedir="${!outputInclude}"/include --mandir="${!outputMan}"/share/man --infodir="${!outputInfo}"/share/info --docdir="${!outputDoc}"/share/doc/"${shareDocName}" --libdir="${!outputLib}"/lib --libexecdir="${!outputLib}"/libexec --localedir="${!outputLib}"/share/locale; + prependToVar installFlags pkgconfigdir="${!outputDev}"/lib/pkgconfig m4datadir="${!outputDev}"/share/aclocal aclocaldir="${!outputDev}"/share/aclocal +} +_multioutDevs () +{ + + if [ "$(getAllOutputNames)" = "out" ] || [ -z "${moveToDev-1}" ]; then + return; + fi; + moveToOutput include "${!outputInclude}"; + moveToOutput lib/pkgconfig "${!outputDev}"; + moveToOutput share/pkgconfig "${!outputDev}"; + moveToOutput lib/cmake "${!outputDev}"; + moveToOutput share/aclocal "${!outputDev}"; + for f in "${!outputDev}"/{lib,share}/pkgconfig/*.pc; + do + echo "Patching '$f' includedir to output ${!outputInclude}"; + sed -i "/^includedir=/s,=\${prefix},=${!outputInclude}," "$f"; + done +} +_multioutDocs () +{ + + local REMOVE=REMOVE; + moveToOutput share/info "${!outputInfo}"; + moveToOutput share/doc "${!outputDoc}"; + moveToOutput share/gtk-doc "${!outputDevdoc}"; + moveToOutput share/devhelp/books "${!outputDevdoc}"; + moveToOutput share/man "${!outputMan}"; + moveToOutput share/man/man3 "${!outputDevman}" +} +_multioutPropagateDev () +{ + + if [ "$(getAllOutputNames)" = "out" ]; then + return; + fi; + local outputFirst; + for outputFirst in $(getAllOutputNames); + do + break; + done; + local propagaterOutput="$outputDev"; + if [ -z "$propagaterOutput" ]; then + propagaterOutput="$outputFirst"; + fi; + if [ -z "${propagatedBuildOutputs+1}" ]; then + local po_dirty="$outputBin $outputInclude $outputLib"; + set +o pipefail; + propagatedBuildOutputs=`echo "$po_dirty" | tr -s ' ' '\n' | grep -v -F "$propagaterOutput" | sort -u | tr '\n' ' ' `; + set -o pipefail; + fi; + if [ -z "$propagatedBuildOutputs" ]; then + return; + fi; + mkdir -p "${!propagaterOutput}"/nix-support; + for output in $propagatedBuildOutputs; + do + echo -n " ${!output}" >> "${!propagaterOutput}"/nix-support/propagated-build-inputs; + done +} +_nixLogWithLevel () +{ + + [[ -z ${NIX_LOG_FD-} || ${NIX_DEBUG:-0} -lt ${1:?} ]] && return 0; + local logLevel; + case "${1:?}" in + 0) + logLevel=ERROR + ;; + 1) + logLevel=WARN + ;; + 2) + logLevel=NOTICE + ;; + 3) + logLevel=INFO + ;; + 4) + logLevel=TALKATIVE + ;; + 5) + logLevel=CHATTY + ;; + 6) + logLevel=DEBUG + ;; + 7) + logLevel=VOMIT + ;; + *) + echo "_nixLogWithLevel: called with invalid log level: ${1:?}" >&"$NIX_LOG_FD"; + return 1 + ;; + esac; + local callerName="${FUNCNAME[2]}"; + if [[ $callerName == "_callImplicitHook" ]]; then + callerName="${hookName:?}"; + fi; + printf "%s: %s: %s\n" "$logLevel" "$callerName" "${2:?}" >&"$NIX_LOG_FD" +} +_overrideFirst () +{ + + if [ -z "${!1-}" ]; then + _assignFirst "$@"; + fi +} +_pruneLibtoolFiles () +{ + + if [ "${dontPruneLibtoolFiles-}" ] || [ ! -e "$prefix" ]; then + return; + fi; + find "$prefix" -type f -name '*.la' -exec grep -q '^# Generated by .*libtool' {} \; -exec grep -q "^old_library=''" {} \; -exec sed -i {} -e "/^dependency_libs='[^']/ c dependency_libs='' #pruned" \; +} +_updateSourceDateEpochFromSourceRoot () +{ + + if [ -n "$sourceRoot" ]; then + updateSourceDateEpoch "$sourceRoot"; + fi +} +activatePackage () +{ + + local pkg="$1"; + local -r hostOffset="$2"; + local -r targetOffset="$3"; + (( hostOffset <= targetOffset )) || exit 1; + if [ -f "$pkg" ]; then + nixTalkativeLog "sourcing setup hook '$pkg'"; + source "$pkg"; + fi; + if [[ -z "${strictDeps-}" || "$hostOffset" -le -1 ]]; then + addToSearchPath _PATH "$pkg/bin"; + fi; + if (( hostOffset <= -1 )); then + addToSearchPath _XDG_DATA_DIRS "$pkg/share"; + fi; + if [[ "$hostOffset" -eq 0 && -d "$pkg/bin" ]]; then + addToSearchPath _HOST_PATH "$pkg/bin"; + fi; + if [[ -f "$pkg/nix-support/setup-hook" ]]; then + nixTalkativeLog "sourcing setup hook '$pkg/nix-support/setup-hook'"; + source "$pkg/nix-support/setup-hook"; + fi +} +addEnvHooks () +{ + + local depHostOffset="$1"; + shift; + local pkgHookVarsSlice="${pkgHookVarVars[$depHostOffset + 1]}[@]"; + local pkgHookVar; + for pkgHookVar in "${!pkgHookVarsSlice}"; + do + eval "${pkgHookVar}s"'+=("$@")'; + done +} +addNodePath () +{ + + addToSearchPath NODE_PATH "$1/lib/node_modules" +} +addToSearchPath () +{ + + addToSearchPathWithCustomDelimiter ":" "$@" +} +addToSearchPathWithCustomDelimiter () +{ + + local delimiter="$1"; + local varName="$2"; + local dir="$3"; + if [[ -d "$dir" && "${!varName:+${delimiter}${!varName}${delimiter}}" != *"${delimiter}${dir}${delimiter}"* ]]; then + export "${varName}=${!varName:+${!varName}${delimiter}}${dir}"; + fi +} +appendToVar () +{ + + local -n nameref="$1"; + local useArray type; + if [ -n "$__structuredAttrs" ]; then + useArray=true; + else + useArray=false; + fi; + if type=$(declare -p "$1" 2> /dev/null); then + case "${type#* }" in + -A*) + echo "appendToVar(): ERROR: trying to use appendToVar on an associative array, use variable+=([\"X\"]=\"Y\") instead." 1>&2; + return 1 + ;; + -a*) + useArray=true + ;; + *) + useArray=false + ;; + esac; + fi; + shift; + if $useArray; then + nameref=(${nameref+"${nameref[@]}"} "$@"); + else + nameref="${nameref-} $*"; + fi +} +auditTmpdir () +{ + + local dir="$1"; + [ -e "$dir" ] || return 0; + echo "checking for references to $TMPDIR/ in $dir..."; + local tmpdir elf_fifo script_fifo; + tmpdir="$(mktemp -d)"; + elf_fifo="$tmpdir/elf"; + script_fifo="$tmpdir/script"; + mkfifo "$elf_fifo" "$script_fifo"; + ( find "$dir" -type f -not -path '*/.build-id/*' -print0 | while IFS= read -r -d '' file; do + if isELF "$file"; then + printf '%s\0' "$file" 1>&3; + else + if isScript "$file"; then + filename=${file##*/}; + dir=${file%/*}; + if [ -e "$dir/.$filename-wrapped" ]; then + printf '%s\0' "$file" 1>&4; + fi; + fi; + fi; + done; + exec 3>&- 4>&- ) 3> "$elf_fifo" 4> "$script_fifo" & ( xargs -0 -r -P "$NIX_BUILD_CORES" -n 1 sh -c ' + if { printf :; patchelf --print-rpath "$1"; } | grep -q -F ":$TMPDIR/"; then + echo "RPATH of binary $1 contains a forbidden reference to $TMPDIR/" + exit 1 + fi + ' _ < "$elf_fifo" ) & local pid_elf=$!; + local pid_script; + ( xargs -0 -r -P "$NIX_BUILD_CORES" -n 1 sh -c ' + if grep -q -F "$TMPDIR/" "$1"; then + echo "wrapper script $1 contains a forbidden reference to $TMPDIR/" + exit 1 + fi + ' _ < "$script_fifo" ) & local pid_script=$!; + wait "$pid_elf" || { + echo "Some binaries contain forbidden references to $TMPDIR/. Check the error above!"; + exit 1 + }; + wait "$pid_script" || { + echo "Some scripts contain forbidden references to $TMPDIR/. Check the error above!"; + exit 1 + }; + rm -r "$tmpdir" +} +bintoolsWrapper_addLDVars () +{ + + local role_post; + getHostRoleEnvHook; + if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then + export NIX_LDFLAGS${role_post}+=" -L$1/lib64"; + fi; + if [[ -d "$1/lib" ]]; then + local -a glob=($1/lib/lib*); + if [ "${#glob[*]}" -gt 0 ]; then + export NIX_LDFLAGS${role_post}+=" -L$1/lib"; + fi; + fi +} +buildPhase () +{ + + runHook preBuild; + if [[ -z "${makeFlags-}" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then + echo "no Makefile or custom buildPhase, doing nothing"; + else + foundMakefile=1; + local flagsArray=(${enableParallelBuilding:+-j${NIX_BUILD_CORES}} SHELL="$SHELL"); + concatTo flagsArray makeFlags makeFlagsArray buildFlags buildFlagsArray; + echoCmd 'build flags' "${flagsArray[@]}"; + make ${makefile:+-f $makefile} "${flagsArray[@]}"; + unset flagsArray; + fi; + runHook postBuild +} +ccWrapper_addCVars () +{ + + local role_post; + getHostRoleEnvHook; + local found=; + if [ -d "$1/include" ]; then + export NIX_CFLAGS_COMPILE${role_post}+=" -isystem $1/include"; + found=1; + fi; + if [ -d "$1/Library/Frameworks" ]; then + export NIX_CFLAGS_COMPILE${role_post}+=" -iframework $1/Library/Frameworks"; + found=1; + fi; + if [[ -n "" && -n ${NIX_STORE:-} && -n $found ]]; then + local scrubbed="$NIX_STORE/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-${1#"$NIX_STORE"/*-}"; + export NIX_CFLAGS_COMPILE${role_post}+=" -fmacro-prefix-map=$1=$scrubbed"; + fi +} +checkPhase () +{ + + runHook preCheck; + if [[ -z "${foundMakefile:-}" ]]; then + echo "no Makefile or custom checkPhase, doing nothing"; + runHook postCheck; + return; + fi; + if [[ -z "${checkTarget:-}" ]]; then + if make -n ${makefile:+-f $makefile} check > /dev/null 2>&1; then + checkTarget="check"; + else + if make -n ${makefile:+-f $makefile} test > /dev/null 2>&1; then + checkTarget="test"; + fi; + fi; + fi; + if [[ -z "${checkTarget:-}" ]]; then + echo "no check/test target in ${makefile:-Makefile}, doing nothing"; + else + local flagsArray=(${enableParallelChecking:+-j${NIX_BUILD_CORES}} SHELL="$SHELL"); + concatTo flagsArray makeFlags makeFlagsArray checkFlags=VERBOSE=y checkFlagsArray checkTarget; + echoCmd 'check flags' "${flagsArray[@]}"; + make ${makefile:+-f $makefile} "${flagsArray[@]}"; + unset flagsArray; + fi; + runHook postCheck +} +compressManPages () +{ + + local dir="$1"; + if [ -L "$dir"/share ] || [ -L "$dir"/share/man ] || [ ! -d "$dir/share/man" ]; then + return; + fi; + echo "gzipping man pages under $dir/share/man/"; + find "$dir"/share/man/ -type f -a '!' -regex '.*\.\(bz2\|gz\|xz\)$' -print0 | xargs -0 -n1 -P "$NIX_BUILD_CORES" gzip -n -f; + find "$dir"/share/man/ -type l -a '!' -regex '.*\.\(bz2\|gz\|xz\)$' -print0 | sort -z | while IFS= read -r -d '' f; do + local target; + target="$(readlink -f "$f")"; + if [ -f "$target".gz ]; then + ln -sf "$target".gz "$f".gz && rm "$f"; + fi; + done +} +concatStringsSep () +{ + + local sep="$1"; + local name="$2"; + local type oldifs; + if type=$(declare -p "$name" 2> /dev/null); then + local -n nameref="$name"; + case "${type#* }" in + -A*) + echo "concatStringsSep(): ERROR: trying to use concatStringsSep on an associative array." 1>&2; + return 1 + ;; + -a*) + local IFS="$(printf '\036')" + ;; + *) + local IFS=" " + ;; + esac; + local ifs_separated="${nameref[*]}"; + echo -n "${ifs_separated//"$IFS"/"$sep"}"; + fi +} +concatTo () +{ + + local -; + set -o noglob; + local -n targetref="$1"; + shift; + local arg default name type; + for arg in "$@"; + do + IFS="=" read -r name default <<< "$arg"; + local -n nameref="$name"; + if [[ -z "${nameref[*]}" && -n "$default" ]]; then + targetref+=("$default"); + else + if type=$(declare -p "$name" 2> /dev/null); then + case "${type#* }" in + -A*) + echo "concatTo(): ERROR: trying to use concatTo on an associative array." 1>&2; + return 1 + ;; + -a*) + targetref+=("${nameref[@]}") + ;; + *) + if [[ "$name" = *"Array" ]]; then + nixErrorLog "concatTo(): $name is not declared as array, treating as a singleton. This will become an error in future"; + targetref+=(${nameref+"${nameref[@]}"}); + else + targetref+=(${nameref-}); + fi + ;; + esac; + fi; + fi; + done +} +configurePhase () +{ + + runHook preConfigure; + : "${configureScript=}"; + if [[ -z "$configureScript" && -x ./configure ]]; then + configureScript=./configure; + fi; + if [ -z "${dontFixLibtool:-}" ]; then + export lt_cv_deplibs_check_method="${lt_cv_deplibs_check_method-pass_all}"; + local i; + find . -iname "ltmain.sh" -print0 | while IFS='' read -r -d '' i; do + echo "fixing libtool script $i"; + fixLibtool "$i"; + done; + CONFIGURE_MTIME_REFERENCE=$(mktemp configure.mtime.reference.XXXXXX); + find . -executable -type f -name configure -exec grep -l 'GNU Libtool is free software; you can redistribute it and/or modify' {} \; -exec touch -r {} "$CONFIGURE_MTIME_REFERENCE" \; -exec sed -i s_/usr/bin/file_file_g {} \; -exec touch -r "$CONFIGURE_MTIME_REFERENCE" {} \;; + rm -f "$CONFIGURE_MTIME_REFERENCE"; + fi; + if [[ -z "${dontAddPrefix:-}" && -n "$prefix" ]]; then + prependToVar configureFlags "${prefixKey:---prefix=}$prefix"; + fi; + if [[ -f "$configureScript" ]]; then + if [ -z "${dontAddDisableDepTrack:-}" ]; then + if grep -q dependency-tracking "$configureScript"; then + prependToVar configureFlags --disable-dependency-tracking; + fi; + fi; + if [ -z "${dontDisableStatic:-}" ]; then + if grep -q enable-static "$configureScript"; then + prependToVar configureFlags --disable-static; + fi; + fi; + if [ -z "${dontPatchShebangsInConfigure:-}" ]; then + patchShebangs --build "$configureScript"; + fi; + fi; + if [ -n "$configureScript" ]; then + local -a flagsArray; + concatTo flagsArray configureFlags configureFlagsArray; + echoCmd 'configure flags' "${flagsArray[@]}"; + $configureScript "${flagsArray[@]}"; + unset flagsArray; + else + echo "no configure script, doing nothing"; + fi; + runHook postConfigure +} +consumeEntire () +{ + + if IFS='' read -r -d '' "$1"; then + echo "consumeEntire(): ERROR: Input null bytes, won't process" 1>&2; + return 1; + fi +} +distPhase () +{ + + runHook preDist; + local flagsArray=(); + concatTo flagsArray distFlags distFlagsArray distTarget=dist; + echo 'dist flags: %q' "${flagsArray[@]}"; + make ${makefile:+-f $makefile} "${flagsArray[@]}"; + if [ "${dontCopyDist:-0}" != 1 ]; then + mkdir -p "$out/tarballs"; + cp -pvd ${tarballs[*]:-*.tar.gz} "$out/tarballs"; + fi; + runHook postDist +} +dumpVars () +{ + + if [[ "${noDumpEnvVars:-0}" != 1 && -d "$NIX_BUILD_TOP" ]]; then + local old_umask; + old_umask=$(umask); + umask 0077; + export 2> /dev/null > "$NIX_BUILD_TOP/env-vars"; + umask "$old_umask"; + fi +} +echoCmd () +{ + + printf "%s:" "$1"; + shift; + printf ' %q' "$@"; + echo +} +exitHandler () +{ + + exitCode="$?"; + set +e; + if [ -n "${showBuildStats:-}" ]; then + read -r -d '' -a buildTimes < <(times); + echo "build times:"; + echo "user time for the shell ${buildTimes[0]}"; + echo "system time for the shell ${buildTimes[1]}"; + echo "user time for all child processes ${buildTimes[2]}"; + echo "system time for all child processes ${buildTimes[3]}"; + fi; + if (( "$exitCode" != 0 )); then + runHook failureHook; + if [ -n "${succeedOnFailure:-}" ]; then + echo "build failed with exit code $exitCode (ignored)"; + mkdir -p "$out/nix-support"; + printf "%s" "$exitCode" > "$out/nix-support/failed"; + exit 0; + fi; + else + runHook exitHook; + fi; + return "$exitCode" +} +findInputs () +{ + + local -r pkg="$1"; + local -r hostOffset="$2"; + local -r targetOffset="$3"; + (( hostOffset <= targetOffset )) || exit 1; + local varVar="${pkgAccumVarVars[hostOffset + 1]}"; + local varRef="$varVar[$((targetOffset - hostOffset))]"; + local var="${!varRef}"; + unset -v varVar varRef; + local varSlice="$var[*]"; + case " ${!varSlice-} " in + *" $pkg "*) + return 0 + ;; + esac; + unset -v varSlice; + eval "$var"'+=("$pkg")'; + if ! [ -e "$pkg" ]; then + echo "build input $pkg does not exist" 1>&2; + exit 1; + fi; + function mapOffset () + { + local -r inputOffset="$1"; + local -n outputOffset="$2"; + if (( inputOffset <= 0 )); then + outputOffset=$((inputOffset + hostOffset)); + else + outputOffset=$((inputOffset - 1 + targetOffset)); + fi + }; + local relHostOffset; + for relHostOffset in "${allPlatOffsets[@]}"; + do + local files="${propagatedDepFilesVars[relHostOffset + 1]}"; + local hostOffsetNext; + mapOffset "$relHostOffset" hostOffsetNext; + (( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue; + local relTargetOffset; + for relTargetOffset in "${allPlatOffsets[@]}"; + do + (( "$relHostOffset" <= "$relTargetOffset" )) || continue; + local fileRef="${files}[$relTargetOffset - $relHostOffset]"; + local file="${!fileRef}"; + unset -v fileRef; + local targetOffsetNext; + mapOffset "$relTargetOffset" targetOffsetNext; + (( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue; + [[ -f "$pkg/nix-support/$file" ]] || continue; + local pkgNext; + read -r -d '' pkgNext < "$pkg/nix-support/$file" || true; + for pkgNext in $pkgNext; + do + findInputs "$pkgNext" "$hostOffsetNext" "$targetOffsetNext"; + done; + done; + done +} +fixLibtool () +{ + + local search_path; + for flag in $NIX_LDFLAGS; + do + case $flag in + -L*) + search_path+=" ${flag#-L}" + ;; + esac; + done; + sed -i "$1" -e "s^eval \(sys_lib_search_path=\).*^\1'${search_path:-}'^" -e 's^eval sys_lib_.+search_path=.*^^' +} +fixupPhase () +{ + + local output; + for output in $(getAllOutputNames); + do + if [ -e "${!output}" ]; then + chmod -R u+w,u-s,g-s "${!output}"; + fi; + done; + runHook preFixup; + local output; + for output in $(getAllOutputNames); + do + prefix="${!output}" runHook fixupOutput; + done; + recordPropagatedDependencies; + if [ -n "${setupHook:-}" ]; then + mkdir -p "${!outputDev}/nix-support"; + substituteAll "$setupHook" "${!outputDev}/nix-support/setup-hook"; + fi; + if [ -n "${setupHooks:-}" ]; then + mkdir -p "${!outputDev}/nix-support"; + local hook; + for hook in ${setupHooks[@]}; + do + local content; + consumeEntire content < "$hook"; + substituteAllStream content "file '$hook'" >> "${!outputDev}/nix-support/setup-hook"; + unset -v content; + done; + unset -v hook; + fi; + if [ -n "${propagatedUserEnvPkgs[*]:-}" ]; then + mkdir -p "${!outputBin}/nix-support"; + printWords "${propagatedUserEnvPkgs[@]}" > "${!outputBin}/nix-support/propagated-user-env-packages"; + fi; + runHook postFixup +} +genericBuild () +{ + + export GZIP_NO_TIMESTAMPS=1; + if [ -f "${buildCommandPath:-}" ]; then + source "$buildCommandPath"; + return; + fi; + if [ -n "${buildCommand:-}" ]; then + eval "$buildCommand"; + return; + fi; + if [ -z "${phases[*]:-}" ]; then + phases="${prePhases[*]:-} unpackPhase patchPhase ${preConfigurePhases[*]:-} configurePhase ${preBuildPhases[*]:-} buildPhase checkPhase ${preInstallPhases[*]:-} installPhase ${preFixupPhases[*]:-} fixupPhase installCheckPhase ${preDistPhases[*]:-} distPhase ${postPhases[*]:-}"; + fi; + for curPhase in ${phases[*]}; + do + runPhase "$curPhase"; + done +} +getAllOutputNames () +{ + + if [ -n "$__structuredAttrs" ]; then + echo "${!outputs[*]}"; + else + echo "$outputs"; + fi +} +getHostRole () +{ + + getRole "$hostOffset" +} +getHostRoleEnvHook () +{ + + getRole "$depHostOffset" +} +getRole () +{ + + case $1 in + -1) + role_post='_FOR_BUILD' + ;; + 0) + role_post='' + ;; + 1) + role_post='_FOR_TARGET' + ;; + *) + echo "binutils-wrapper-2.44: used as improper sort of dependency" 1>&2; + return 1 + ;; + esac +} +getTargetRole () +{ + + getRole "$targetOffset" +} +getTargetRoleEnvHook () +{ + + getRole "$depTargetOffset" +} +getTargetRoleWrapper () +{ + + case $targetOffset in + -1) + export NIX_BINTOOLS_WRAPPER_TARGET_BUILD_x86_64_unknown_linux_gnu=1 + ;; + 0) + export NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu=1 + ;; + 1) + export NIX_BINTOOLS_WRAPPER_TARGET_TARGET_x86_64_unknown_linux_gnu=1 + ;; + *) + echo "binutils-wrapper-2.44: used as improper sort of dependency" 1>&2; + return 1 + ;; + esac +} +installCheckPhase () +{ + + runHook preInstallCheck; + if [[ -z "${foundMakefile:-}" ]]; then + echo "no Makefile or custom installCheckPhase, doing nothing"; + else + if [[ -z "${installCheckTarget:-}" ]] && ! make -n ${makefile:+-f $makefile} "${installCheckTarget:-installcheck}" > /dev/null 2>&1; then + echo "no installcheck target in ${makefile:-Makefile}, doing nothing"; + else + local flagsArray=(${enableParallelChecking:+-j${NIX_BUILD_CORES}} SHELL="$SHELL"); + concatTo flagsArray makeFlags makeFlagsArray installCheckFlags installCheckFlagsArray installCheckTarget=installcheck; + echoCmd 'installcheck flags' "${flagsArray[@]}"; + make ${makefile:+-f $makefile} "${flagsArray[@]}"; + unset flagsArray; + fi; + fi; + runHook postInstallCheck +} +installPhase () +{ + + runHook preInstall; + if [[ -z "${makeFlags-}" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then + echo "no Makefile or custom installPhase, doing nothing"; + runHook postInstall; + return; + else + foundMakefile=1; + fi; + if [ -n "$prefix" ]; then + mkdir -p "$prefix"; + fi; + local flagsArray=(${enableParallelInstalling:+-j${NIX_BUILD_CORES}} SHELL="$SHELL"); + concatTo flagsArray makeFlags makeFlagsArray installFlags installFlagsArray installTargets=install; + echoCmd 'install flags' "${flagsArray[@]}"; + make ${makefile:+-f $makefile} "${flagsArray[@]}"; + unset flagsArray; + runHook postInstall +} +isELF () +{ + + local fn="$1"; + local fd; + local magic; + exec {fd}< "$fn"; + LANG=C read -r -n 4 -u "$fd" magic; + exec {fd}>&-; + if [ "$magic" = 'ELF' ]; then + return 0; + else + return 1; + fi +} +isMachO () +{ + + local fn="$1"; + local fd; + local magic; + exec {fd}< "$fn"; + LANG=C read -r -n 4 -u "$fd" magic; + exec {fd}>&-; + if [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xcf") || "$magic" = $(echo -ne "\xcf\xfa\xed\xfe") ]]; then + return 0; + else + if [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xce") || "$magic" = $(echo -ne "\xce\xfa\xed\xfe") ]]; then + return 0; + else + if [[ "$magic" = $(echo -ne "\xca\xfe\xba\xbe") || "$magic" = $(echo -ne "\xbe\xba\xfe\xca") ]]; then + return 0; + else + return 1; + fi; + fi; + fi +} +isScript () +{ + + local fn="$1"; + local fd; + local magic; + exec {fd}< "$fn"; + LANG=C read -r -n 2 -u "$fd" magic; + exec {fd}>&-; + if [[ "$magic" =~ \#! ]]; then + return 0; + else + return 1; + fi +} +mapOffset () +{ + + local -r inputOffset="$1"; + local -n outputOffset="$2"; + if (( inputOffset <= 0 )); then + outputOffset=$((inputOffset + hostOffset)); + else + outputOffset=$((inputOffset - 1 + targetOffset)); + fi +} +moveToOutput () +{ + + local patt="$1"; + local dstOut="$2"; + local output; + for output in $(getAllOutputNames); + do + if [ "${!output}" = "$dstOut" ]; then + continue; + fi; + local srcPath; + for srcPath in "${!output}"/$patt; + do + if [ ! -e "$srcPath" ] && [ ! -L "$srcPath" ]; then + continue; + fi; + if [ "$dstOut" = REMOVE ]; then + echo "Removing $srcPath"; + rm -r "$srcPath"; + else + local dstPath="$dstOut${srcPath#${!output}}"; + echo "Moving $srcPath to $dstPath"; + if [ -d "$dstPath" ] && [ -d "$srcPath" ]; then + rmdir "$srcPath" --ignore-fail-on-non-empty; + if [ -d "$srcPath" ]; then + mv -t "$dstPath" "$srcPath"/*; + rmdir "$srcPath"; + fi; + else + mkdir -p "$(readlink -m "$dstPath/..")"; + mv "$srcPath" "$dstPath"; + fi; + fi; + local srcParent="$(readlink -m "$srcPath/..")"; + if [ -n "$(find "$srcParent" -maxdepth 0 -type d -empty 2> /dev/null)" ]; then + echo "Removing empty $srcParent/ and (possibly) its parents"; + rmdir -p --ignore-fail-on-non-empty "$srcParent" 2> /dev/null || true; + fi; + done; + done +} +nixChattyLog () +{ + + _nixLogWithLevel 5 "$*" +} +nixDebugLog () +{ + + _nixLogWithLevel 6 "$*" +} +nixErrorLog () +{ + + _nixLogWithLevel 0 "$*" +} +nixInfoLog () +{ + + _nixLogWithLevel 3 "$*" +} +nixLog () +{ + + [[ -z ${NIX_LOG_FD-} ]] && return 0; + local callerName="${FUNCNAME[1]}"; + if [[ $callerName == "_callImplicitHook" ]]; then + callerName="${hookName:?}"; + fi; + printf "%s: %s\n" "$callerName" "$*" >&"$NIX_LOG_FD" +} +nixNoticeLog () +{ + + _nixLogWithLevel 2 "$*" +} +nixTalkativeLog () +{ + + _nixLogWithLevel 4 "$*" +} +nixVomitLog () +{ + + _nixLogWithLevel 7 "$*" +} +nixWarnLog () +{ + + _nixLogWithLevel 1 "$*" +} +noBrokenSymlinks () +{ + + local -r output="${1:?}"; + local path; + local pathParent; + local symlinkTarget; + local -i numDanglingSymlinks=0; + local -i numReflexiveSymlinks=0; + local -i numUnreadableSymlinks=0; + if [[ ! -e $output ]]; then + nixWarnLog "skipping non-existent output $output"; + return 0; + fi; + nixInfoLog "running on $output"; + while IFS= read -r -d '' path; do + pathParent="$(dirname "$path")"; + if ! symlinkTarget="$(readlink "$path")"; then + nixErrorLog "the symlink $path is unreadable"; + numUnreadableSymlinks+=1; + continue; + fi; + if [[ $symlinkTarget == /* ]]; then + nixInfoLog "symlink $path points to absolute target $symlinkTarget"; + else + nixInfoLog "symlink $path points to relative target $symlinkTarget"; + symlinkTarget="$(realpath --no-symlinks --canonicalize-missing "$pathParent/$symlinkTarget")"; + fi; + if [[ $symlinkTarget = "$TMPDIR"/* ]]; then + nixErrorLog "the symlink $path points to $TMPDIR directory: $symlinkTarget"; + numDanglingSymlinks+=1; + continue; + fi; + if [[ $symlinkTarget != "$NIX_STORE"/* ]]; then + nixInfoLog "symlink $path points outside the Nix store; ignoring"; + continue; + fi; + if [[ $path == "$symlinkTarget" ]]; then + nixErrorLog "the symlink $path is reflexive"; + numReflexiveSymlinks+=1; + else + if [[ ! -e $symlinkTarget ]]; then + nixErrorLog "the symlink $path points to a missing target: $symlinkTarget"; + numDanglingSymlinks+=1; + else + nixDebugLog "the symlink $path is irreflexive and points to a target which exists"; + fi; + fi; + done < <(find "$output" -type l -print0); + if ((numDanglingSymlinks > 0 || numReflexiveSymlinks > 0 || numUnreadableSymlinks > 0)); then + nixErrorLog "found $numDanglingSymlinks dangling symlinks, $numReflexiveSymlinks reflexive symlinks and $numUnreadableSymlinks unreadable symlinks"; + exit 1; + fi; + return 0 +} +noBrokenSymlinksInAllOutputs () +{ + + if [[ -z ${dontCheckForBrokenSymlinks-} ]]; then + for output in $(getAllOutputNames); + do + noBrokenSymlinks "${!output}"; + done; + fi +} +patchELF () +{ + + local dir="$1"; + [ -e "$dir" ] || return 0; + echo "shrinking RPATHs of ELF executables and libraries in $dir"; + local i; + while IFS= read -r -d '' i; do + if [[ "$i" =~ .build-id ]]; then + continue; + fi; + if ! isELF "$i"; then + continue; + fi; + echo "shrinking $i"; + patchelf --shrink-rpath "$i" || true; + done < <(find "$dir" -type f -print0) +} +patchPhase () +{ + + runHook prePatch; + local -a patchesArray; + concatTo patchesArray patches; + local -a flagsArray; + concatTo flagsArray patchFlags=-p1; + for i in "${patchesArray[@]}"; + do + echo "applying patch $i"; + local uncompress=cat; + case "$i" in + *.gz) + uncompress="gzip -d" + ;; + *.bz2) + uncompress="bzip2 -d" + ;; + *.xz) + uncompress="xz -d" + ;; + *.lzma) + uncompress="lzma -d" + ;; + esac; + $uncompress < "$i" 2>&1 | patch "${flagsArray[@]}"; + done; + runHook postPatch +} +patchShebangs () +{ + + local pathName; + local update=false; + while [[ $# -gt 0 ]]; do + case "$1" in + --host) + pathName=HOST_PATH; + shift + ;; + --build) + pathName=PATH; + shift + ;; + --update) + update=true; + shift + ;; + --) + shift; + break + ;; + -* | --*) + echo "Unknown option $1 supplied to patchShebangs" 1>&2; + return 1 + ;; + *) + break + ;; + esac; + done; + echo "patching script interpreter paths in $@"; + local f; + local oldPath; + local newPath; + local arg0; + local args; + local oldInterpreterLine; + local newInterpreterLine; + if [[ $# -eq 0 ]]; then + echo "No arguments supplied to patchShebangs" 1>&2; + return 0; + fi; + local f; + while IFS= read -r -d '' f; do + isScript "$f" || continue; + read -r oldInterpreterLine < "$f" || [ "$oldInterpreterLine" ]; + read -r oldPath arg0 args <<< "${oldInterpreterLine:2}"; + if [[ -z "${pathName:-}" ]]; then + if [[ -n $strictDeps && $f == "$NIX_STORE"* ]]; then + pathName=HOST_PATH; + else + pathName=PATH; + fi; + fi; + if [[ "$oldPath" == *"/bin/env" ]]; then + if [[ $arg0 == "-S" ]]; then + arg0=${args%% *}; + [[ "$args" == *" "* ]] && args=${args#* } || args=; + newPath="$(PATH="${!pathName}" type -P "env" || true)"; + args="-S $(PATH="${!pathName}" type -P "$arg0" || true) $args"; + else + if [[ $arg0 == "-"* || $arg0 == *"="* ]]; then + echo "$f: unsupported interpreter directive \"$oldInterpreterLine\" (set dontPatchShebangs=1 and handle shebang patching yourself)" 1>&2; + exit 1; + else + newPath="$(PATH="${!pathName}" type -P "$arg0" || true)"; + fi; + fi; + else + if [[ -z $oldPath ]]; then + oldPath="/bin/sh"; + fi; + newPath="$(PATH="${!pathName}" type -P "$(basename "$oldPath")" || true)"; + args="$arg0 $args"; + fi; + newInterpreterLine="$newPath $args"; + newInterpreterLine=${newInterpreterLine%${newInterpreterLine##*[![:space:]]}}; + if [[ -n "$oldPath" && ( "$update" == true || "${oldPath:0:${#NIX_STORE}}" != "$NIX_STORE" ) ]]; then + if [[ -n "$newPath" && "$newPath" != "$oldPath" ]]; then + echo "$f: interpreter directive changed from \"$oldInterpreterLine\" to \"$newInterpreterLine\""; + escapedInterpreterLine=${newInterpreterLine//\\/\\\\}; + timestamp=$(stat --printf "%y" "$f"); + tmpFile=$(mktemp -t patchShebangs.XXXXXXXXXX); + sed -e "1 s|.*|#\!$escapedInterpreterLine|" "$f" > "$tmpFile"; + local restoreReadOnly; + if [[ ! -w "$f" ]]; then + chmod +w "$f"; + restoreReadOnly=true; + fi; + cat "$tmpFile" > "$f"; + rm "$tmpFile"; + if [[ -n "${restoreReadOnly:-}" ]]; then + chmod -w "$f"; + fi; + touch --date "$timestamp" "$f"; + fi; + fi; + done < <(find "$@" -type f -perm -0100 -print0) +} +patchShebangsAuto () +{ + + if [[ -z "${dontPatchShebangs-}" && -e "$prefix" ]]; then + if [[ "$output" != out && "$output" = "$outputDev" ]]; then + patchShebangs --build "$prefix"; + else + patchShebangs --host "$prefix"; + fi; + fi +} +prependToVar () +{ + + local -n nameref="$1"; + local useArray type; + if [ -n "$__structuredAttrs" ]; then + useArray=true; + else + useArray=false; + fi; + if type=$(declare -p "$1" 2> /dev/null); then + case "${type#* }" in + -A*) + echo "prependToVar(): ERROR: trying to use prependToVar on an associative array." 1>&2; + return 1 + ;; + -a*) + useArray=true + ;; + *) + useArray=false + ;; + esac; + fi; + shift; + if $useArray; then + nameref=("$@" ${nameref+"${nameref[@]}"}); + else + nameref="$* ${nameref-}"; + fi +} +printLines () +{ + + (( "$#" > 0 )) || return 0; + printf '%s\n' "$@" +} +printWords () +{ + + (( "$#" > 0 )) || return 0; + printf '%s ' "$@" +} +recordPropagatedDependencies () +{ + + declare -ra flatVars=(depsBuildBuildPropagated propagatedNativeBuildInputs depsBuildTargetPropagated depsHostHostPropagated propagatedBuildInputs depsTargetTargetPropagated); + declare -ra flatFiles=("${propagatedBuildDepFiles[@]}" "${propagatedHostDepFiles[@]}" "${propagatedTargetDepFiles[@]}"); + local propagatedInputsIndex; + for propagatedInputsIndex in "${!flatVars[@]}"; + do + local propagatedInputsSlice="${flatVars[$propagatedInputsIndex]}[@]"; + local propagatedInputsFile="${flatFiles[$propagatedInputsIndex]}"; + [[ -n "${!propagatedInputsSlice}" ]] || continue; + mkdir -p "${!outputDev}/nix-support"; + printWords ${!propagatedInputsSlice} > "${!outputDev}/nix-support/$propagatedInputsFile"; + done +} +runHook () +{ + + local hookName="$1"; + shift; + local hooksSlice="${hookName%Hook}Hooks[@]"; + local hook; + for hook in "_callImplicitHook 0 $hookName" ${!hooksSlice+"${!hooksSlice}"}; + do + _logHook "$hookName" "$hook" "$@"; + _eval "$hook" "$@"; + done; + return 0 +} +runOneHook () +{ + + local hookName="$1"; + shift; + local hooksSlice="${hookName%Hook}Hooks[@]"; + local hook ret=1; + for hook in "_callImplicitHook 1 $hookName" ${!hooksSlice+"${!hooksSlice}"}; + do + _logHook "$hookName" "$hook" "$@"; + if _eval "$hook" "$@"; then + ret=0; + break; + fi; + done; + return "$ret" +} +runPhase () +{ + + local curPhase="$*"; + if [[ "$curPhase" = unpackPhase && -n "${dontUnpack:-}" ]]; then + return; + fi; + if [[ "$curPhase" = patchPhase && -n "${dontPatch:-}" ]]; then + return; + fi; + if [[ "$curPhase" = configurePhase && -n "${dontConfigure:-}" ]]; then + return; + fi; + if [[ "$curPhase" = buildPhase && -n "${dontBuild:-}" ]]; then + return; + fi; + if [[ "$curPhase" = checkPhase && -z "${doCheck:-}" ]]; then + return; + fi; + if [[ "$curPhase" = installPhase && -n "${dontInstall:-}" ]]; then + return; + fi; + if [[ "$curPhase" = fixupPhase && -n "${dontFixup:-}" ]]; then + return; + fi; + if [[ "$curPhase" = installCheckPhase && -z "${doInstallCheck:-}" ]]; then + return; + fi; + if [[ "$curPhase" = distPhase && -z "${doDist:-}" ]]; then + return; + fi; + showPhaseHeader "$curPhase"; + dumpVars; + local startTime endTime; + startTime=$(date +"%s"); + eval "${!curPhase:-$curPhase}"; + endTime=$(date +"%s"); + showPhaseFooter "$curPhase" "$startTime" "$endTime"; + if [ "$curPhase" = unpackPhase ]; then + [ -n "${sourceRoot:-}" ] && chmod +x -- "${sourceRoot}"; + cd -- "${sourceRoot:-.}"; + fi +} +showPhaseFooter () +{ + + local phase="$1"; + local startTime="$2"; + local endTime="$3"; + local delta=$(( endTime - startTime )); + (( delta < 30 )) && return; + local H=$((delta/3600)); + local M=$((delta%3600/60)); + local S=$((delta%60)); + echo -n "$phase completed in "; + (( H > 0 )) && echo -n "$H hours "; + (( M > 0 )) && echo -n "$M minutes "; + echo "$S seconds" +} +showPhaseHeader () +{ + + local phase="$1"; + echo "Running phase: $phase"; + if [[ -z ${NIX_LOG_FD-} ]]; then + return; + fi; + printf "@nix { \"action\": \"setPhase\", \"phase\": \"%s\" }\n" "$phase" >&"$NIX_LOG_FD" +} +stripDirs () +{ + + local cmd="$1"; + local ranlibCmd="$2"; + local paths="$3"; + local stripFlags="$4"; + local excludeFlags=(); + local pathsNew=; + [ -z "$cmd" ] && echo "stripDirs: Strip command is empty" 1>&2 && exit 1; + [ -z "$ranlibCmd" ] && echo "stripDirs: Ranlib command is empty" 1>&2 && exit 1; + local pattern; + if [ -n "${stripExclude:-}" ]; then + for pattern in "${stripExclude[@]}"; + do + excludeFlags+=(-a '!' '(' -name "$pattern" -o -wholename "$prefix/$pattern" ')'); + done; + fi; + local p; + for p in ${paths}; + do + if [ -e "$prefix/$p" ]; then + pathsNew="${pathsNew} $prefix/$p"; + fi; + done; + paths=${pathsNew}; + if [ -n "${paths}" ]; then + echo "stripping (with command $cmd and flags $stripFlags) in $paths"; + local striperr; + striperr="$(mktemp --tmpdir="$TMPDIR" 'striperr.XXXXXX')"; + find $paths -type f "${excludeFlags[@]}" -a '!' -path "$prefix/lib/debug/*" -printf '%D-%i,%p\0' | sort -t, -k1,1 -u -z | cut -d, -f2- -z | xargs -r -0 -n1 -P "$NIX_BUILD_CORES" -- $cmd $stripFlags 2> "$striperr" || exit_code=$?; + [[ "$exit_code" = 123 || -z "$exit_code" ]] || ( cat "$striperr" 1>&2 && exit 1 ); + rm "$striperr"; + find $paths -name '*.a' -type f -exec $ranlibCmd '{}' \; 2> /dev/null; + fi +} +stripHash () +{ + + local strippedName casematchOpt=0; + strippedName="$(basename -- "$1")"; + shopt -q nocasematch && casematchOpt=1; + shopt -u nocasematch; + if [[ "$strippedName" =~ ^[a-z0-9]{32}- ]]; then + echo "${strippedName:33}"; + else + echo "$strippedName"; + fi; + if (( casematchOpt )); then + shopt -s nocasematch; + fi +} +substitute () +{ + + local input="$1"; + local output="$2"; + shift 2; + if [ ! -f "$input" ]; then + echo "substitute(): ERROR: file '$input' does not exist" 1>&2; + return 1; + fi; + local content; + consumeEntire content < "$input"; + if [ -e "$output" ]; then + chmod +w "$output"; + fi; + substituteStream content "file '$input'" "$@" > "$output" +} +substituteAll () +{ + + local input="$1"; + local output="$2"; + local -a args=(); + _allFlags; + substitute "$input" "$output" "${args[@]}" +} +substituteAllInPlace () +{ + + local fileName="$1"; + shift; + substituteAll "$fileName" "$fileName" "$@" +} +substituteAllStream () +{ + + local -a args=(); + _allFlags; + substituteStream "$1" "$2" "${args[@]}" +} +substituteInPlace () +{ + + local -a fileNames=(); + for arg in "$@"; + do + if [[ "$arg" = "--"* ]]; then + break; + fi; + fileNames+=("$arg"); + shift; + done; + if ! [[ "${#fileNames[@]}" -gt 0 ]]; then + echo "substituteInPlace called without any files to operate on (files must come before options!)" 1>&2; + return 1; + fi; + for file in "${fileNames[@]}"; + do + substitute "$file" "$file" "$@"; + done +} +substituteStream () +{ + + local var=$1; + local description=$2; + shift 2; + while (( "$#" )); do + local replace_mode="$1"; + case "$1" in + --replace) + if ! "$_substituteStream_has_warned_replace_deprecation"; then + echo "substituteStream() in derivation $name: WARNING: '--replace' is deprecated, use --replace-{fail,warn,quiet}. ($description)" 1>&2; + _substituteStream_has_warned_replace_deprecation=true; + fi; + replace_mode='--replace-warn' + ;& + --replace-quiet | --replace-warn | --replace-fail) + pattern="$2"; + replacement="$3"; + shift 3; + if ! [[ "${!var}" == *"$pattern"* ]]; then + if [ "$replace_mode" == --replace-warn ]; then + printf "substituteStream() in derivation $name: WARNING: pattern %q doesn't match anything in %s\n" "$pattern" "$description" 1>&2; + else + if [ "$replace_mode" == --replace-fail ]; then + printf "substituteStream() in derivation $name: ERROR: pattern %q doesn't match anything in %s\n" "$pattern" "$description" 1>&2; + return 1; + fi; + fi; + fi; + eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}' + ;; + --subst-var) + local varName="$2"; + shift 2; + if ! [[ "$varName" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then + echo "substituteStream() in derivation $name: ERROR: substitution variables must be valid Bash names, \"$varName\" isn't." 1>&2; + return 1; + fi; + if [ -z ${!varName+x} ]; then + echo "substituteStream() in derivation $name: ERROR: variable \$$varName is unset" 1>&2; + return 1; + fi; + pattern="@$varName@"; + replacement="${!varName}"; + eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}' + ;; + --subst-var-by) + pattern="@$2@"; + replacement="$3"; + eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}'; + shift 3 + ;; + *) + echo "substituteStream() in derivation $name: ERROR: Invalid command line argument: $1" 1>&2; + return 1 + ;; + esac; + done; + printf "%s" "${!var}" +} +unpackFile () +{ + + curSrc="$1"; + echo "unpacking source archive $curSrc"; + if ! runOneHook unpackCmd "$curSrc"; then + echo "do not know how to unpack source archive $curSrc"; + exit 1; + fi +} +unpackPhase () +{ + + runHook preUnpack; + if [ -z "${srcs:-}" ]; then + if [ -z "${src:-}" ]; then + echo 'variable $src or $srcs should point to the source'; + exit 1; + fi; + srcs="$src"; + fi; + local -a srcsArray; + concatTo srcsArray srcs; + local dirsBefore=""; + for i in *; + do + if [ -d "$i" ]; then + dirsBefore="$dirsBefore $i "; + fi; + done; + for i in "${srcsArray[@]}"; + do + unpackFile "$i"; + done; + : "${sourceRoot=}"; + if [ -n "${setSourceRoot:-}" ]; then + runOneHook setSourceRoot; + else + if [ -z "$sourceRoot" ]; then + for i in *; + do + if [ -d "$i" ]; then + case $dirsBefore in + *\ $i\ *) + + ;; + *) + if [ -n "$sourceRoot" ]; then + echo "unpacker produced multiple directories"; + exit 1; + fi; + sourceRoot="$i" + ;; + esac; + fi; + done; + fi; + fi; + if [ -z "$sourceRoot" ]; then + echo "unpacker appears to have produced no directories"; + exit 1; + fi; + echo "source root is $sourceRoot"; + if [ "${dontMakeSourcesWritable:-0}" != 1 ]; then + chmod -R u+w -- "$sourceRoot"; + fi; + runHook postUnpack +} +updateAutotoolsGnuConfigScriptsPhase () +{ + + if [ -n "${dontUpdateAutotoolsGnuConfigScripts-}" ]; then + return; + fi; + for script in config.sub config.guess; + do + for f in $(find . -type f -name "$script"); + do + echo "Updating Autotools / GNU config script to a newer upstream version: $f"; + cp -f "/nix/store/ambacmwlhkwlx6ngxccsa9z1wdszgwjx-gnu-config-2024-01-01/$script" "$f"; + done; + done +} +updateSourceDateEpoch () +{ + + local path="$1"; + [[ $path == -* ]] && path="./$path"; + local -a res=($(find "$path" -type f -not -newer "$NIX_BUILD_TOP/.." -printf '%T@ "%p"\0' | sort -n --zero-terminated | tail -n1 --zero-terminated | head -c -1)); + local time="${res[0]//\.[0-9]*/}"; + local newestFile="${res[1]}"; + if [ "${time:-0}" -gt "$SOURCE_DATE_EPOCH" ]; then + echo "setting SOURCE_DATE_EPOCH to timestamp $time of file $newestFile"; + export SOURCE_DATE_EPOCH="$time"; + local now="$(date +%s)"; + if [ "$time" -gt $((now - 60)) ]; then + echo "warning: file $newestFile may be generated; SOURCE_DATE_EPOCH may be non-deterministic"; + fi; + fi +} +PATH="$PATH${nix_saved_PATH:+:$nix_saved_PATH}" +XDG_DATA_DIRS="$XDG_DATA_DIRS${nix_saved_XDG_DATA_DIRS:+:$nix_saved_XDG_DATA_DIRS}" +export NIX_BUILD_TOP="$(mktemp -d -t nix-shell.XXXXXX)" +export TMP="$NIX_BUILD_TOP" +export TMPDIR="$NIX_BUILD_TOP" +export TEMP="$NIX_BUILD_TOP" +export TEMPDIR="$NIX_BUILD_TOP" +eval "${shellHook:-}" diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..4baea90 --- /dev/null +++ b/.envrc @@ -0,0 +1,6 @@ +if ! has nix_direnv_version || ! nix_direnv_version 3.1.0; then + source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.1.0/direnvrc" "sha256-yMJ2OVMzrFaDPn7q8nCBZFRYpL/f0RcHzhmw/i6btJM=" +fi + +nix_direnv_manual_reload +use flake diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..2a1fd20 --- /dev/null +++ b/flake.lock @@ -0,0 +1,61 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1762844143, + "narHash": "sha256-SlybxLZ1/e4T2lb1czEtWVzDCVSTvk9WLwGhmxFmBxI=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "9da7f1cf7f8a6e2a7cb3001b048546c92a8258b4", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix index cc04f18..fcfa38b 100644 --- a/flake.nix +++ b/flake.nix @@ -6,7 +6,7 @@ flake-utils.url = "github:numtide/flake-utils"; }; - outputs = { self, nixpkgs, flake-utils }: + outputs = { nixpkgs, flake-utils, ... }: flake-utils.lib.eachDefaultSystem (system: let pkgs = nixpkgs.legacyPackages.${system}; diff --git a/lib.js b/lib.js index de689de..5ea1f50 100644 --- a/lib.js +++ b/lib.js @@ -1,5 +1,10 @@ 'use strict'; +var buttonModule = require('buttons'); +var ir = require('ir'); +var flichub = require('flicapp'); +var hubinfo = require('hubinfo'); + function makeLogger(prefix) { var debugMode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false; return { @@ -26,7 +31,7 @@ function makeLogger(prefix) { }; } -function _define_property$3(obj, key, value) { +function _define_property$6(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, @@ -39,7 +44,7 @@ function _define_property$3(obj, key, value) { } return obj; } -function _object_spread$3(target) { +function _object_spread$6(target) { for(var i = 1; i < arguments.length; i++){ var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); @@ -49,17 +54,44 @@ function _object_spread$3(target) { })); } ownKeys.forEach(function(key) { - _define_property$3(target, key, source[key]); + _define_property$6(target, key, source[key]); }); } return target; } -var makeOptions$2 = function(opt) { - return _object_spread$3({ +var makeOptions$3 = function(opt) { + return _object_spread$6({ debug: false }, opt); }; + +var getDeviceFromButton = function(button) { + return { + name: button.name, + identifiers: [ + button.serialNumber, + button.uuid + ], + manufacturer: "Flic", + model: "v".concat(button.flicVersion, "_").concat(button.color.trim().length > 0 ? button.color : "white"), + sw_version: String(button.firmwareVersion), + hw_version: String(button.flicVersion), + serial_number: String(button.serialNumber), + configuration_url: "https://hubsdk.flic.io/" + }; +}; +var genButtonUniqueId = function(bdaddr) { + return bdaddr.replace(/:/g, "_"); +}; + var ENTITIES = { + name: [ + "sensor", + { + entity_category: "diagnostic", + name: "Button Name" + } + ], action: [ "sensor", { @@ -81,27 +113,6 @@ var ENTITIES = { device_class: "battery" } ], - batteryLastUpdate: [ - "sensor", - { - entity_category: "diagnostic", - expire_after: 5, - name: "Battery Last Update Time", - device_class: "duration", - unit_of_measurement: "s" - } - ], - lifeline: [ - "binary_sensor", - { - entity_category: "diagnostic", - expire_after: 5, - name: "Flichub Connected", - device_class: "connectivity", - unit_of_measurement: "s", - payload_not_available: "OFF" - } - ], connected: [ "binary_sensor", { @@ -165,31 +176,41 @@ var ENTITIES = { } ] }; -function makeButtonController(ha, buttonModule) { - var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; - options = makeOptions$2(options); - var logger = makeLogger("btnc", options.debug); - logger.info("Starting Flic ButtonController with", JSON.stringify(options, null, 4)); - var getDeviceFromButton = function(button) { - return { - name: button.name, - identifiers: [ - button.serialNumber, - button.uuid - ], - manufacturer: "Flic", - model: "v".concat(button.flicVersion, "_").concat(button.color.trim().length > 0 ? button.color : "white"), - sw: String(button.firmwareVersion), - hw: String(button.flicVersion), - configuration_url: "https://hubsdk.flic.io/" - }; - }; - var genButtonUniqueId = function(bdaddr) { - return bdaddr.replace(/:/g, "_"); - }; + +function _define_property$5(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _object_spread$5(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i] != null ? arguments[i] : {}; + var ownKeys = Object.keys(source); + if (typeof Object.getOwnPropertySymbols === "function") { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + ownKeys.forEach(function(key) { + _define_property$5(target, key, source[key]); + }); + } + return target; +} +var ButtonStateHandler = function(ha, logger) { var registerButton = function(button) { logger.info("Registering", JSON.stringify(button, null, 4)); var haDevice = getDeviceFromButton(button); + var uniqId = genButtonUniqueId(button.bdaddr); + ha.startLifeLine("Button Controller Connected", uniqId, haDevice); Object.keys(ENTITIES).forEach(function(objectId) { var avl = { availability: [ @@ -206,9 +227,6 @@ function makeButtonController(ha, buttonModule) { ], availability_mode: "all" }; - if (objectId === "lifeline") { - avl = {}; - } if (objectId === "ready" || objectId == "connected") { avl.availability = [ avl.availability[1] @@ -217,100 +235,317 @@ function makeButtonController(ha, buttonModule) { if (ENTITIES[objectId][0] === "device_automation") { avl = {}; } - ha.registerEntity("Button ".concat(objectId), ENTITIES[objectId][0], genButtonUniqueId(button.bdaddr), objectId, haDevice, _object_spread$3({}, ENTITIES[objectId][1], avl)); + ha.registerEntity("Button ".concat(objectId), ENTITIES[objectId][0], uniqId, objectId, haDevice, _object_spread$5({}, ENTITIES[objectId][1], avl)); }); }; - var deregisterButton = function(button) { - logger.info("Deregistering", JSON.stringify(button, null, 4)); + var deregisterButton = function(bdaddr) { + var uniqId = genButtonUniqueId(bdaddr); + logger.info("Deregistering", JSON.stringify({ + bdaddr: bdaddr, + uniqId: uniqId + }, null, 4)); Object.keys(ENTITIES).forEach(function(objectId) { - ha.deregisterEntity(ENTITIES[objectId][0], genButtonUniqueId(button.bdaddr), objectId); + ha.deregisterEntity(ENTITIES[objectId][0], uniqId, objectId); }); }; - var publishButtonState = function(button, state) { - ha.publishState(genButtonUniqueId(button.bdaddr), "state", state); + var publishButtonState = function(bdaddr, state) { + logger.debug('Updating state for bdaddr="'.concat(bdaddr, '" state=').concat(state)); + ha.publishState(genButtonUniqueId(bdaddr), "state", state); }; - var publishButtonAction = function(button, state) { - ha.publishState(genButtonUniqueId(button.bdaddr), "action", state); + var publishButtonAction = function(bdaddr, state) { + var uniqId = genButtonUniqueId(bdaddr); + ha.publishState(uniqId, "action", state); + logger.debug('Publishing click for bdaddr="'.concat(bdaddr, '" uniqId="').concat(uniqId, '" state=').concat(state)); if (state === "click") { - ha.publishState(genButtonUniqueId(button.bdaddr), "button_short_press", "ON"); + ha.publishState(uniqId, "button_short_press", "ON"); } else if (state === "double_click") { - ha.publishState(genButtonUniqueId(button.bdaddr), "button_double_press", "ON"); + ha.publishState(uniqId, "button_double_press", "ON"); } else if (state === "hold") { - ha.publishState(genButtonUniqueId(button.bdaddr), "button_long_press", "ON"); + ha.publishState(uniqId, "button_long_press", "ON"); } }; - var publishButtonMeta = function(button) { - ha.publishState(genButtonUniqueId(button.bdaddr), "battery", button.batteryStatus); - ha.publishState(genButtonUniqueId(button.bdaddr), "batteryLastUpdate", button.batteryTimestamp ? "".concat(Math.round((Date.now() - button.batteryTimestamp) / 1000)) : "unknown"); - ha.publishState(genButtonUniqueId(button.bdaddr), "connected", button.connected ? "ON" : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), "ready", button.ready ? "ON" : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), "activeDisconnect", button.activeDisconnect ? "ON" : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), "passive", button.activeDisconnect ? "ON" : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), "lifeline", "ON"); + var publishButtonMeta = function(bdaddr) { + var button = buttonModule.getButton(bdaddr); + var uniqId = genButtonUniqueId(button.bdaddr); + ha.publishState(uniqId, "name", button.name); + ha.publishState(uniqId, "battery", button.batteryStatus); + ha.publishState(uniqId, "connected", button.connected ? "ON" : "OFF"); + ha.publishState(uniqId, "ready", button.ready ? "ON" : "OFF"); + ha.publishState(uniqId, "activeDisconnect", button.activeDisconnect ? "ON" : "OFF"); + ha.publishState(uniqId, "passive", button.activeDisconnect ? "ON" : "OFF"); + ha.publishState(uniqId, "lifeline", "ON"); }; - var addBtn = function(eventName) { - return function(obj) { - var button = buttonModule.getButton(obj.bdaddr); - logger.info(eventName, "upserting", button.name, genButtonUniqueId(button.bdaddr)); - registerButton(button); - }; + var handleBtnCreation = function(eventName, obj) { + var button = buttonModule.getButton(obj.bdaddr); + logger.info(eventName, "upserting", button.name, genButtonUniqueId(button.bdaddr)); + registerButton(button); }; - var start = function() { - logger.info("Starting..."); + return { + addBtn: function(eventName) { + return function(o) { + return handleBtnCreation(eventName, o); + }; + }, + addBtnWithObject: function(eventName) { + return function(o) { + return handleBtnCreation(eventName, o.button); + }; + }, + publishButtonMeta: publishButtonMeta, + publishButtonAction: publishButtonAction, + publishButtonState: publishButtonState, + registerButton: registerButton, + deregisterButton: deregisterButton + }; +}; + +function makeButtonController(ha) { + var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + options = makeOptions$3(options); + var logger = makeLogger("btnc", options.debug); + logger.info("Starting Flic ButtonController with", JSON.stringify(options, null, 4)); + var stateHandler = ButtonStateHandler(ha, logger); + var setListeners = function() { var resetActiontInv = null; - buttonModule.on("buttonAdded", addBtn("buttonAdded")); - buttonModule.on("buttonConnected", addBtn("buttonConnected")); - buttonModule.on("buttonReady", function(btn) { - addBtn("buttonReady")(btn); - var button = buttonModule.getButton(btn.bdaddr); - publishButtonState(button, "released"); - publishButtonAction(button, "none"); - }); - buttonModule.on("buttonUpdated", addBtn("buttonUpdated")); + buttonModule.on("buttonAdded", stateHandler.addBtnWithObject("buttonAdded")); + buttonModule.on("buttonUpdated", stateHandler.addBtnWithObject("buttonUpdated")); buttonModule.on("buttonDeleted", function(btn) { logger.debug("buttonDeleted", JSON.stringify(btn, null, 4)); - deregisterButton(btn); - publishButtonMeta(btn); + stateHandler.deregisterButton(btn.bdaddr); + stateHandler.publishButtonMeta(btn.bdaddr); + }); + buttonModule.on("buttonConnected", stateHandler.addBtn("buttonConnected")); + buttonModule.on("buttonReady", function(btn) { + stateHandler.addBtn("buttonReady")(btn); + stateHandler.publishButtonState(btn.bdaddr, "released"); + stateHandler.publishButtonAction(btn.bdaddr, "none"); }); buttonModule.on("buttonDisconnected", function(param) { var bdaddr = param.bdaddr; - publishButtonMeta(buttonModule.getButton(bdaddr)); + stateHandler.publishButtonMeta(bdaddr); }); buttonModule.on("buttonDown", function(param) { var bdaddr = param.bdaddr; - var btn = buttonModule.getButton(bdaddr); - publishButtonState(btn, "pressed"); - publishButtonMeta(btn); + stateHandler.publishButtonState(bdaddr, "pressed"); + stateHandler.publishButtonMeta(bdaddr); }); buttonModule.on("buttonUp", function(param) { var bdaddr = param.bdaddr; - var btn = buttonModule.getButton(bdaddr); - publishButtonState(btn, "released"); - publishButtonMeta(btn); + stateHandler.publishButtonState(bdaddr, "released"); + stateHandler.publishButtonMeta(bdaddr); }); + buttonModule.on("buttonClickOrHold", function(obj) {}); buttonModule.on("buttonSingleOrDoubleClickOrHold", function(obj) { if (resetActiontInv !== null) { clearTimeout(resetActiontInv); } - var btn = buttonModule.getButton(obj.bdaddr); - publishButtonAction(btn, obj.isSingleClick ? "click" : obj.isDoubleClick ? "double_click" : "hold"); - publishButtonMeta(btn); + stateHandler.publishButtonAction(obj.bdaddr, obj.isSingleClick ? "click" : obj.isDoubleClick ? "double_click" : "hold"); + stateHandler.publishButtonMeta(obj.bdaddr); resetActiontInv = setTimeout(function() { - publishButtonAction(btn, "none"); + stateHandler.publishButtonAction(obj.bdaddr, "none"); }, 500); }); + }; + var start = function() { + logger.info("Starting..."); + logger.info("Setting listeners..."); + setListeners(); logger.info("Registering all buttons..."); - buttonModule.getButtons().forEach(registerButton); + buttonModule.getButtons().forEach(function(btn) { + return stateHandler.registerButton(btn); + }); setInterval(function() { - return buttonModule.getButtons().forEach(publishButtonMeta); + logger.debug("Updating button state!"); + buttonModule.getButtons().forEach(function(btn) { + return stateHandler.publishButtonMeta(btn.bdaddr); + }); }, 3000); logger.info("is up"); }; return { start: start, - publishButtonAction: publishButtonAction, - publishButtonMeta: publishButtonMeta, - publishButtonState: publishButtonState + publishButtonAction: stateHandler.publishButtonAction, + publishButtonMeta: stateHandler.publishButtonMeta, + publishButtonState: stateHandler.publishButtonState + }; +} + +function _define_property$4(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _object_spread$4(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i] != null ? arguments[i] : {}; + var ownKeys = Object.keys(source); + if (typeof Object.getOwnPropertySymbols === "function") { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + ownKeys.forEach(function(key) { + _define_property$4(target, key, source[key]); + }); + } + return target; +} +function ownKeys$2(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + keys.push.apply(keys, symbols); + } + return keys; +} +function _object_spread_props$2(target, source) { + source = source != null ? source : {}; + if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys$2(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + return target; +} +var makeOptions$2 = function(opt) { + return _object_spread_props$2(_object_spread$4({ + debug: false + }, opt), { + topics: _object_spread$4({ + homeassistant: "homeassistant", + flic: "flic" + }, opt.topics) + }); +}; + +function _define_property$3(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _object_spread$3(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i] != null ? arguments[i] : {}; + var ownKeys = Object.keys(source); + if (typeof Object.getOwnPropertySymbols === "function") { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + ownKeys.forEach(function(key) { + _define_property$3(target, key, source[key]); + }); + } + return target; +} +function ownKeys$1(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + keys.push.apply(keys, symbols); + } + return keys; +} +function _object_spread_props$1(target, source) { + source = source != null ? source : {}; + if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys$1(Object(source)).forEach(function(key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + return target; +} +function makeHAmqtt(mqttServer) { + var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + options = makeOptions$2(options); + var logger = makeLogger("mqtt:ha", options.debug); + logger.info("starting...", JSON.stringify(options, null, 4)); + var genFlicPrefix = function(nodeId, objectId) { + return "".concat(options.topics.flic, "/").concat(nodeId, "/").concat(objectId); + }; + var genFlicPrefixObject = function(nodeId, objectId) { + return { + nodeId: nodeId, + objectId: objectId, + mqttPrefix: genFlicPrefix(nodeId, objectId) + }; + }; + var genHAPrefix = function(component, nodeId, objectId) { + return "".concat(options.topics.homeassistant, "/").concat(component, "/").concat(nodeId, "/").concat(objectId); + }; + var publishState = function(nodeId, objectId, state) { + var opt = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}; + var btntopic = genFlicPrefix(nodeId, objectId); + mqttServer.publish(btntopic, state + "", opt); + logger.debug(btntopic, state, JSON.stringify(opt)); + }; + var registerEntity = function(name, component, nodeId, objectId, device) { + var additionalProps = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : {}; + var configtopic = genHAPrefix(component, nodeId, objectId) + "/config"; + if (component === "device_automation") { + additionalProps.topic = genFlicPrefix(nodeId, objectId); + } else { + additionalProps.state_topic = genFlicPrefix(nodeId, objectId); + } + var configObj = _object_spread_props$1(_object_spread$3({ + name: name + }, additionalProps), { + unique_id: "Flic_".concat(nodeId, "_").concat(objectId), + device: device + }); + mqttServer.publish(configtopic, JSON.stringify(configObj), { + retain: true + }); + logger.debug(configtopic, JSON.stringify(configObj, null, 4)); + }; + var deregisterEntity = function(component, nodeId, objectId) { + var configtopic = genHAPrefix(component, nodeId, objectId) + "/config"; + mqttServer.publish(configtopic, null, { + retain: false + }); + logger.debug(configtopic, null); + }; + var startLifeLine = function(name, nodeId, haDevice) { + var topic = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "lifeline"; + registerEntity(name, "binary_sensor", nodeId, topic, haDevice, { + device_class: "connectivity", + expire_after: 5, + off_delay: 3, + entity_category: "diagnostic", + payload_available: "ON", + payload_not_available: "OFF" + }); + setInterval(function() { + publishState(nodeId, topic, "ON"); + }, 2500); + }; + return { + deregisterEntity: deregisterEntity, + registerEntity: registerEntity, + publishState: publishState, + genFlicPrefix: genFlicPrefix, + genFlicPrefixObject: genFlicPrefixObject, + startLifeLine: startLifeLine }; } @@ -342,120 +577,7 @@ function _object_spread$2(target) { } return target; } -function ownKeys$1(object, enumerableOnly) { - var keys = Object.keys(object); - if (Object.getOwnPropertySymbols) { - var symbols = Object.getOwnPropertySymbols(object); - if (enumerableOnly) { - symbols = symbols.filter(function(sym) { - return Object.getOwnPropertyDescriptor(object, sym).enumerable; - }); - } - keys.push.apply(keys, symbols); - } - return keys; -} -function _object_spread_props$1(target, source) { - source = source != null ? source : {}; - if (Object.getOwnPropertyDescriptors) { - Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); - } else { - ownKeys$1(Object(source)).forEach(function(key) { - Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); - }); - } - return target; -} -var makeOptions$1 = function(opt) { - return _object_spread_props$1(_object_spread$2({ - debug: false - }, opt), { - topics: _object_spread$2({ - homeassistant: "homeassistant", - flic: "flic" - }, opt.topics) - }); -}; -function makeHAmqtt(mqttServer) { - var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - options = makeOptions$1(options); - var logger = makeLogger("mqtt:ha", options.debug); - logger.info("starting...", JSON.stringify(options, null, 4)); - var genFlicPrefix = function(nodeId, objectId) { - return "".concat(options.topics.flic, "/").concat(nodeId, "/").concat(objectId); - }; - var genHAPrefix = function(component, nodeId, objectId) { - return "".concat(options.topics.homeassistant, "/").concat(component, "/").concat(nodeId, "/").concat(objectId); - }; - var publishState = function(nodeId, objectId, state) { - var opt = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}; - var btntopic = genFlicPrefix(nodeId, objectId); - mqttServer.publish(btntopic, state + "", opt); - logger.debug(btntopic, state, JSON.stringify(opt)); - }; - var registerEntity = function(name, component, nodeId, objectId, device) { - var additionalProps = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : {}; - var configtopic = genHAPrefix(component, nodeId, objectId) + "/config"; - if (component === "device_automation") { - additionalProps.topic = genFlicPrefix(nodeId, objectId); - } else { - additionalProps.state_topic = genFlicPrefix(nodeId, objectId); - } - var configObj = _object_spread_props$1(_object_spread$2({ - name: name - }, additionalProps), { - unique_id: "Flic_".concat(nodeId, "_").concat(objectId), - device: device - }); - mqttServer.publish(configtopic, JSON.stringify(configObj), { - retain: true - }); - logger.debug(configtopic, JSON.stringify(configObj, null, 4)); - }; - var deregisterEntity = function(component, nodeId, objectId) { - var configtopic = genHAPrefix(component, nodeId, objectId) + "/config"; - mqttServer.publish(configtopic, null, { - retain: false - }); - logger.debug(configtopic, null); - }; - return { - deregisterEntity: deregisterEntity, - registerEntity: registerEntity, - publishState: publishState, - genFlicPrefix: genFlicPrefix - }; -} - -function _define_property$1(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { - value: value, - enumerable: true, - configurable: true, - writable: true - }); - } else { - obj[key] = value; - } - return obj; -} -function _object_spread$1(target) { - for(var i = 1; i < arguments.length; i++){ - var source = arguments[i] != null ? arguments[i] : {}; - var ownKeys = Object.keys(source); - if (typeof Object.getOwnPropertySymbols === "function") { - ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { - return Object.getOwnPropertyDescriptor(source, sym).enumerable; - })); - } - ownKeys.forEach(function(key) { - _define_property$1(target, key, source[key]); - }); - } - return target; -} -var NODE_ID = "FlicHubIR"; +var NODE_ID$1 = "FlicHubIR"; var convertUint32Array2Str = function(arr) { var outStr = []; for(var i = 0; i < arr.length; i++){ @@ -469,26 +591,27 @@ var convertStr2Uint32Array = function(s) { return parseInt(v, 32); })); }; -var makeOptions = function(opt) { - return _object_spread$1({ +var makeOptions$1 = function(opt) { + return _object_spread$2({ debug: false, uniqueId: "0" }, opt); }; -var makeIRController = function(ir, ha, mqtt) { - var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}; - options = makeOptions(options); + +var makeIRController = function(ha, mqtt) { + var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + options = makeOptions$1(options); var logger = makeLogger("ir", options.debug); var haDevice = { name: "IR", manufacturer: "Flic", - model: "".concat(NODE_ID).concat(options.uniqueId), + model: "".concat(NODE_ID$1).concat(options.uniqueId), identifiers: [ "FlicHubIR" ], configuration_url: "https://hubsdk.flic.io/" }; - var nodeId = "".concat(NODE_ID).concat(options.uniqueId); + var nodeId = "".concat(NODE_ID$1).concat(options.uniqueId); var LIFELINE_SGINAL = ha.genFlicPrefix(nodeId, "lifeline"); var RECORD_SIGNAL_SET = ha.genFlicPrefix(nodeId, "record/set"); var VALUE_SIGNAL_SET = ha.genFlicPrefix(nodeId, "signal/set"); @@ -512,6 +635,7 @@ var makeIRController = function(ir, ha, mqtt) { start: function start() { logger.info("starting..."); logger.debug("setting up entities..."); + ha.startLifeLine("IR Connnected", nodeId, haDevice); ha.registerEntity("IR Available", "binary_sensor", nodeId, "lifeline", haDevice, { device_class: "connectivity", expire_after: 5, @@ -596,9 +720,6 @@ var makeIRController = function(ir, ha, mqtt) { }); logger.debug("subscribing to", set_topics); mqtt.subscribe(set_topics); - setInterval(function() { - ha.publishState(nodeId, "lifeline", "ON"); - }, 2500); logger.info("is up"); } }; @@ -660,7 +781,7 @@ function _unsupported_iterable_to_array(o, minLen) { var C = { PROTOCOL_LEVEL: 4, DEF_PORT: 1883, - DEF_KEEP_ALIVE: 60 // Default keep_alive (s) + DEF_KEEP_ALIVE: 60 }; /** Control packet types */ var TYPE = { CONNECT: 1, @@ -705,7 +826,7 @@ Uint8Array.prototype.charCodeAt = function(a, b) { this.client = false; this.connected = false; /* if keep_alive is less than the ping interval we need to use - a shorter ping interval, otherwise we'll just time out! */ this.ping_interval = this.keep_alive < this.C.PING_INTERVAL ? this.keep_alive - 5 : this.C.PING_INTERVAL; + a shorter ping interval, otherwise we'll just time out! */ this.ping_interval = this.keep_alive < this.C.PING_INTERVAL ? this.keep_alive - 5 : this.C.PING_INTERVAL; this.protocol_name = options.protocol_name || "MQTT"; this.protocol_level = options.protocol_level || C.PROTOCOL_LEVEL; if (typeof this.client_id == "string") { @@ -779,7 +900,7 @@ if (!Buffer.from) { /** 'public' constants here */ MQTT.prototype.C = { DEF_QOS: 0, CONNECT_TIMEOUT: 10000, - PING_INTERVAL: 40 // Server ping interval (s) + PING_INTERVAL: 40 }; /* Utility functions ***************************/ var fromCharCode = String.fromCharCode; /** MQTT string (length MSB, LSB + data) */ function mqttStr(s) { @@ -871,7 +992,7 @@ function mqttInt2Str(arr) { pakId = pakId > 65534 ? 1 : ++pakId; return [ pakId >> 8, - pakId & 0xFF + pakId & 0xff ]; } /** Get PID from message */ function getPid(data) { @@ -926,11 +1047,6 @@ MQTT.prototype.packetHandler = function(data) { this.partData = data; return; } - // Allow zero-size pData, but detect if its indexes - // will go out of bounds. - if (1 + dLen.lenBy >= data.length) { - return; - } // Get the data for this packet var pData = data.slice(1 + dLen.lenBy, pLen); // more than one packet? re-emit it so we handle it later @@ -1089,11 +1205,11 @@ MQTT.prototype.packetHandler = function(data) { this.client = false; }; /** Publish message using specified topic. - opts = { - retain: bool // the server should retain this message and send it out again to new subscribers - dup : bool // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) - } - */ MQTT.prototype.publish = function(topic, message, opts) { + opts = { + retain: bool // the server should retain this message and send it out again to new subscribers + dup : bool // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) + } +*/ MQTT.prototype.publish = function(topic, message, opts) { if (!this.client) return; opts = opts || {}; try { @@ -1193,6 +1309,117 @@ MQTT.prototype.packetHandler = function(data) { return new MQTT(server, options); } +function _define_property$1(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _object_spread$1(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i] != null ? arguments[i] : {}; + var ownKeys = Object.keys(source); + if (typeof Object.getOwnPropertySymbols === "function") { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + ownKeys.forEach(function(key) { + _define_property$1(target, key, source[key]); + }); + } + return target; +} +var NODE_ID = "FlicHub"; +var makeOptions = function(opt) { + return _object_spread$1({ + debug: false, + uniqueId: "0" + }, opt); +}; +var getHADevice = function(options) { + return { + name: "FlicHub (".concat(options.uniqueId, ")"), + manufacturer: "Flic", + model: "".concat(NODE_ID).concat(options.uniqueId), + identifiers: [ + "FlicHub" + ], + configuration_url: "https://hubsdk.flic.io/", + sw_version: hubinfo.firmwareVersion, + serial_number: hubinfo.serialNumber + }; +}; +var getConstants = function(ha, options) { + var nodeId = "".concat(NODE_ID).concat(options.uniqueId); + return { + NODE_ID: nodeId, + LIFELINE_SGINAL: ha.genFlicPrefixObject(nodeId, "lifeline"), + MESSAGE: ha.genFlicPrefixObject(nodeId, "action-message"), + COMMAND_TOPIC: function(virtualId) { + return ha.genFlicPrefixObject(nodeId, "virt-command-".concat(virtualId)); + } + }; +}; + +var genVirtualDeviceObjectId = function(param) { + var virtualDeviceId = param.virtualDeviceId, dimmableType = param.dimmableType; + return "virt-".concat(dimmableType, "-").concat(virtualDeviceId).toLowerCase(); +}; +var VirtualDeviceType2HAComponent = { + Blind: "cover", + Light: "light", + Speaker: "media_player" +}; +var virtualDeviceUpdateHandler = function(ha, logger, haDevice, nodeId, update, commandTopic, availability) { + var objectId = genVirtualDeviceObjectId(update.metaData); + var mqttPrefix = ha.genFlicPrefixObject(nodeId, objectId); + logger.info("Handling update for ".concat(update, " on ").concat(haDevice)); + ha.registerEntity(update.metaData.virtualDeviceId, VirtualDeviceType2HAComponent[update.metaData.dimmableType], mqttPrefix.nodeId, mqttPrefix.objectId, haDevice, { + availability: availability, + command_topic: commandTopic + }); + ha.publishState(mqttPrefix.nodeId, mqttPrefix.objectId, { + brightness: update.values.brightness * 255 + }); +}; + +var startFlicHubController = function(ha, mqtt) { + var _options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + var options = makeOptions(_options); + var logger = makeLogger("flichub", options.debug); + var haDevice = getHADevice(options); + var constants = getConstants(ha, options); + var availability = [ + { + payload_available: "ON", + payload_not_available: "unavailable", + topic: constants.LIFELINE_SGINAL.mqttPrefix + } + ]; + logger.info("starting..."); + logger.debug("setting up entities..."); + ha.startLifeLine("FlicHub Connected", constants.NODE_ID, haDevice, constants.LIFELINE_SGINAL.objectId); + ha.registerEntity("Action Message", "sensor", constants.NODE_ID, constants.MESSAGE.objectId, haDevice, { + icon: "mdi:message", + availability: availability + }); + ha.publishState(constants.NODE_ID, constants.MESSAGE.objectId, ""); + flichub.on("actionMessage", function(obj) { + ha.publishState(constants.NODE_ID, constants.MESSAGE.objectId, obj); + }); + flichub.on("virtualDeviceUpdate", function(update) { + return virtualDeviceUpdateHandler(ha, logger, haDevice, constants.NODE_ID, update, constants.COMMAND_TOPIC(update.metaData.virtualDeviceId), availability); + }); +}; + function _define_property(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { @@ -1225,11 +1452,6 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); - if (enumerableOnly) { - symbols = symbols.filter(function(sym) { - return Object.getOwnPropertyDescriptor(object, sym).enumerable; - }); - } keys.push.apply(keys, symbols); } return keys; @@ -1245,7 +1467,7 @@ function _object_spread_props(target, source) { } return target; } -var start = function(buttonModule, irModule, options) { +var start = function(options) { var mqttServer = create(options.mqtt.host, _object_spread_props(_object_spread({}, options.mqtt), { keep_alive: true })); @@ -1257,21 +1479,28 @@ var start = function(buttonModule, irModule, options) { options.flicBtns = (_options_flicBtns = options.flicBtns) !== null && _options_flicBtns !== void 0 ? _options_flicBtns : {}; var _options_flicIR; options.flicIR = (_options_flicIR = options.flicIR) !== null && _options_flicIR !== void 0 ? _options_flicIR : {}; + var _options_flicHub; + options.flicHub = (_options_flicHub = options.flicHub) !== null && _options_flicHub !== void 0 ? _options_flicHub : {}; var _options_ha_debug, _ref; options.ha.debug = (_ref = (_options_ha_debug = options.ha.debug) !== null && _options_ha_debug !== void 0 ? _options_ha_debug : options.debug) !== null && _ref !== void 0 ? _ref : false; var _options_flicBtns_debug, _ref1; options.flicBtns.debug = (_ref1 = (_options_flicBtns_debug = options.flicBtns.debug) !== null && _options_flicBtns_debug !== void 0 ? _options_flicBtns_debug : options.debug) !== null && _ref1 !== void 0 ? _ref1 : false; - var _options_flicBtns_debug1, _ref2; - options.flicIR.debug = (_ref2 = (_options_flicBtns_debug1 = options.flicBtns.debug) !== null && _options_flicBtns_debug1 !== void 0 ? _options_flicBtns_debug1 : options.debug) !== null && _ref2 !== void 0 ? _ref2 : false; + var _options_flicIR_debug, _ref2; + options.flicIR.debug = (_ref2 = (_options_flicIR_debug = options.flicIR.debug) !== null && _options_flicIR_debug !== void 0 ? _options_flicIR_debug : options.debug) !== null && _ref2 !== void 0 ? _ref2 : false; + var _options_flicHub_debug, _ref3; + options.flicHub.debug = (_ref3 = (_options_flicHub_debug = options.flicHub.debug) !== null && _options_flicHub_debug !== void 0 ? _options_flicHub_debug : options.debug) !== null && _ref3 !== void 0 ? _ref3 : false; var ha = makeHAmqtt(mqttServer, options.ha); mqttServer.on("connected", function() { - var _options_flicBtns, _options_flicIR; + var _options_flicBtns, _options_flicIR, _options_flicHub; logger.info("connected to mqtt"); if (!((_options_flicBtns = options.flicBtns) === null || _options_flicBtns === void 0 ? void 0 : _options_flicBtns.disabled)) { - makeButtonController(ha, buttonModule, options.flicBtns).start(); + makeButtonController(ha, options.flicBtns).start(); } if (!((_options_flicIR = options.flicIR) === null || _options_flicIR === void 0 ? void 0 : _options_flicIR.disabled)) { - makeIRController(irModule, ha, mqttServer, options.flicIR).start(); + makeIRController(ha, mqttServer, options.flicIR).start(); + } + if (!((_options_flicHub = options.flicHub) === null || _options_flicHub === void 0 ? void 0 : _options_flicHub.disabled)) { + startFlicHubController(ha, mqttServer, options.flicHub); } logger.info("all services up!"); }); diff --git a/package-lock.json b/package-lock.json index 6f21eec..e3a8eda 100644 --- a/package-lock.json +++ b/package-lock.json @@ -70,156 +70,308 @@ } }, "node_modules/@rollup/rollup-android-arm-eabi": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.2.0.tgz", - "integrity": "sha512-8PlggAxGxavr+pkCNeV1TM2wTb2o+cUWDg9M1cm9nR27Dsn287uZtSLYXoQqQcmq+sYfF7lHfd3sWJJinH9GmA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.53.2.tgz", + "integrity": "sha512-yDPzwsgiFO26RJA4nZo8I+xqzh7sJTZIWQOxn+/XOdPE31lAvLIYCKqjV+lNH/vxE2L2iH3plKxDCRK6i+CwhA==", "cpu": [ "arm" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "android" ] }, "node_modules/@rollup/rollup-android-arm64": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.2.0.tgz", - "integrity": "sha512-+71T85hbMFrJI+zKQULNmSYBeIhru55PYoF/u75MyeN2FcxE4HSPw20319b+FcZ4lWx2Nx/Ql9tN+hoaD3GH/A==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.53.2.tgz", + "integrity": "sha512-k8FontTxIE7b0/OGKeSN5B6j25EuppBcWM33Z19JoVT7UTXFSo3D9CdU39wGTeb29NO3XxpMNauh09B+Ibw+9g==", "cpu": [ "arm64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "android" ] }, "node_modules/@rollup/rollup-darwin-arm64": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.2.0.tgz", - "integrity": "sha512-IIIQLuG43QIElT1JZqUP/zqIdiJl4t9U/boa0GZnQTw9m1X0k3mlBuysbgYXeloLT1RozdL7bgw4lpSaI8GOXw==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.53.2.tgz", + "integrity": "sha512-A6s4gJpomNBtJ2yioj8bflM2oogDwzUiMl2yNJ2v9E7++sHrSrsQ29fOfn5DM/iCzpWcebNYEdXpaK4tr2RhfQ==", "cpu": [ "arm64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "darwin" ] }, "node_modules/@rollup/rollup-darwin-x64": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.2.0.tgz", - "integrity": "sha512-BXcXvnLaea1Xz900omrGJhxHFJfH9jZ0CpJuVsbjjhpniJ6qiLXz3xA8Lekaa4MuhFcJd4f0r+Ky1G4VFbYhWw==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.53.2.tgz", + "integrity": "sha512-e6XqVmXlHrBlG56obu9gDRPW3O3hLxpwHpLsBJvuI8qqnsrtSZ9ERoWUXtPOkY8c78WghyPHZdmPhHLWNdAGEw==", "cpu": [ "x64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "darwin" ] }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.53.2.tgz", + "integrity": "sha512-v0E9lJW8VsrwPux5Qe5CwmH/CF/2mQs6xU1MF3nmUxmZUCHazCjLgYvToOk+YuuUqLQBio1qkkREhxhc656ViA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.53.2.tgz", + "integrity": "sha512-ClAmAPx3ZCHtp6ysl4XEhWU69GUB1D+s7G9YjHGhIGCSrsg00nEGRRZHmINYxkdoJehde8VIsDC5t9C0gb6yqA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, "node_modules/@rollup/rollup-linux-arm-gnueabihf": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.2.0.tgz", - "integrity": "sha512-f4K3MKw9Y4AKi4ANGnmPIglr+S+8tO858YrGVuqAHXxJdVghBmz9CPU9kDpOnGvT4g4vg5uNyIFpOOFvffXyMA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.53.2.tgz", + "integrity": "sha512-EPlb95nUsz6Dd9Qy13fI5kUPXNSljaG9FiJ4YUGU1O/Q77i5DYFW5KR8g1OzTcdZUqQQ1KdDqsTohdFVwCwjqg==", "cpu": [ "arm" ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.53.2.tgz", + "integrity": "sha512-BOmnVW+khAUX+YZvNfa0tGTEMVVEerOxN0pDk2E6N6DsEIa2Ctj48FOMfNDdrwinocKaC7YXUZ1pHlKpnkja/Q==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ] }, "node_modules/@rollup/rollup-linux-arm64-gnu": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.2.0.tgz", - "integrity": "sha512-bNsTYQBgp4H7w6cT7FZhesxpcUPahsSIy4NgdZjH1ZwEoZHxi4XKglj+CsSEkhsKi+x6toVvMylhjRKhEMYfnA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.53.2.tgz", + "integrity": "sha512-Xt2byDZ+6OVNuREgBXr4+CZDJtrVso5woFtpKdGPhpTPHcNG7D8YXeQzpNbFRxzTVqJf7kvPMCub/pcGUWgBjA==", "cpu": [ "arm64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ] }, "node_modules/@rollup/rollup-linux-arm64-musl": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.2.0.tgz", - "integrity": "sha512-Jp1NxBJpGLuxRU2ihrQk4IZ+ia5nffobG6sOFUPW5PMYkF0kQtxEbeDuCa69Xif211vUOcxlOnf5IOEIpTEySA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.53.2.tgz", + "integrity": "sha512-+LdZSldy/I9N8+klim/Y1HsKbJ3BbInHav5qE9Iy77dtHC/pibw1SR/fXlWyAk0ThnpRKoODwnAuSjqxFRDHUQ==", "cpu": [ "arm64" ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.53.2.tgz", + "integrity": "sha512-8ms8sjmyc1jWJS6WdNSA23rEfdjWB30LH8Wqj0Cqvv7qSHnvw6kgMMXRdop6hkmGPlyYBdRPkjJnj3KCUHV/uQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.53.2.tgz", + "integrity": "sha512-3HRQLUQbpBDMmzoxPJYd3W6vrVHOo2cVW8RUo87Xz0JPJcBLBr5kZ1pGcQAhdZgX9VV7NbGNipah1omKKe23/g==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.53.2.tgz", + "integrity": "sha512-fMjKi+ojnmIvhk34gZP94vjogXNNUKMEYs+EDaB/5TG/wUkoeua7p7VCHnE6T2Tx+iaghAqQX8teQzcvrYpaQA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.53.2.tgz", + "integrity": "sha512-XuGFGU+VwUUV5kLvoAdi0Wz5Xbh2SrjIxCtZj6Wq8MDp4bflb/+ThZsVxokM7n0pcbkEr2h5/pzqzDYI7cCgLQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.53.2.tgz", + "integrity": "sha512-w6yjZF0P+NGzWR3AXWX9zc0DNEGdtvykB03uhonSHMRa+oWA6novflo2WaJr6JZakG2ucsyb+rvhrKac6NIy+w==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ] }, "node_modules/@rollup/rollup-linux-x64-gnu": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.2.0.tgz", - "integrity": "sha512-3p3iRtQmv2aXw+vtKNyZMLOQ+LSRsqArXjKAh2Oj9cqwfIRe7OXvdkOzWfZOIp1F/x5KJzVAxGxnniF4cMbnsQ==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.53.2.tgz", + "integrity": "sha512-yo8d6tdfdeBArzC7T/PnHd7OypfI9cbuZzPnzLJIyKYFhAQ8SvlkKtKBMbXDxe1h03Rcr7u++nFS7tqXz87Gtw==", "cpu": [ "x64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ] }, "node_modules/@rollup/rollup-linux-x64-musl": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.2.0.tgz", - "integrity": "sha512-atih7IF/reUZe4LBLC5Izd44hth2tfDIG8LaPp4/cQXdHh9jabcZEvIeRPrpDq0i/Uu487Qu5gl5KwyAnWajnw==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.53.2.tgz", + "integrity": "sha512-ah59c1YkCxKExPP8O9PwOvs+XRLKwh/mV+3YdKqQ5AMQ0r4M4ZDuOrpWkUaqO7fzAHdINzV9tEVu8vNw48z0lA==", "cpu": [ "x64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ] }, - "node_modules/@rollup/rollup-win32-arm64-msvc": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.2.0.tgz", - "integrity": "sha512-vYxF3tKJeUE4ceYzpNe2p84RXk/fGK30I8frpRfv/MyPStej/mRlojztkN7Jtd1014HHVeq/tYaMBz/3IxkxZw==", + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.53.2.tgz", + "integrity": "sha512-4VEd19Wmhr+Zy7hbUsFZ6YXEiP48hE//KPLCSVNY5RMGX2/7HZ+QkN55a3atM1C/BZCGIgqN+xrVgtdak2S9+A==", "cpu": [ "arm64" ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.53.2.tgz", + "integrity": "sha512-IlbHFYc/pQCgew/d5fslcy1KEaYVCJ44G8pajugd8VoOEI8ODhtb/j8XMhLpwHCMB3yk2J07ctup10gpw2nyMA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", "optional": true, "os": [ "win32" ] }, "node_modules/@rollup/rollup-win32-ia32-msvc": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.2.0.tgz", - "integrity": "sha512-1LZJ6zpl93SaPQvas618bMFarVwufWTaczH4ESAbFcwiC4OtznA6Ym+hFPyIGaJaGEB8uMWWac0uXGPXOg5FGA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.53.2.tgz", + "integrity": "sha512-lNlPEGgdUfSzdCWU176ku/dQRnA7W+Gp8d+cWv73jYrb8uT7HTVVxq62DUYxjbaByuf1Yk0RIIAbDzp+CnOTFg==", "cpu": [ "ia32" ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.53.2.tgz", + "integrity": "sha512-S6YojNVrHybQis2lYov1sd+uj7K0Q05NxHcGktuMMdIQ2VixGwAfbJ23NnlvvVV1bdpR2m5MsNBViHJKcA4ADw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", "optional": true, "os": [ "win32" ] }, "node_modules/@rollup/rollup-win32-x64-msvc": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.2.0.tgz", - "integrity": "sha512-dgQfFdHCNg08nM5zBmqxqc9vrm0DVzhWotpavbPa0j4//MAOKZEB75yGAfzQE9fUJ+4pvM1239Y4IhL8f6sSog==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.53.2.tgz", + "integrity": "sha512-k+/Rkcyx//P6fetPoLMb8pBeqJBNGx81uuf7iljX9++yNBVRDQgD04L+SVXmXmh5ZP4/WOp4mWF0kmi06PW2tA==", "cpu": [ "x64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "win32" @@ -238,14 +390,16 @@ } }, "node_modules/@swc/cli": { - "version": "0.1.62", - "resolved": "https://registry.npmjs.org/@swc/cli/-/cli-0.1.62.tgz", - "integrity": "sha512-kOFLjKY3XH1DWLfXL1/B5MizeNorHR8wHKEi92S/Zi9Md/AK17KSqR8MgyRJ6C1fhKHvbBCl8wboyKAFXStkYw==", + "version": "0.1.65", + "resolved": "https://registry.npmjs.org/@swc/cli/-/cli-0.1.65.tgz", + "integrity": "sha512-4NcgsvJVHhA7trDnMmkGLLvWMHu2kSy+qHx6QwRhhJhdiYdNUrhdp+ERxen73sYtaeEOYeLJcWrQ60nzKi6rpg==", "dev": true, + "license": "MIT", "dependencies": { "@mole-inc/bin-wrapper": "^8.0.1", "commander": "^7.1.0", "fast-glob": "^3.2.5", + "minimatch": "^9.0.3", "semver": "^7.3.8", "slash": "3.0.0", "source-map": "^0.7.3" @@ -508,6 +662,13 @@ "@types/responselike": "^1.0.0" } }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/http-cache-semantics": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.3.tgz", @@ -561,6 +722,13 @@ } ] }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, "node_modules/bin-check": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/bin-check/-/bin-check-4.1.0.tgz", @@ -608,10 +776,11 @@ } }, "node_modules/bin-version/node_modules/cross-spawn": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", - "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "dev": true, + "license": "MIT", "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", @@ -725,13 +894,24 @@ "node": ">= 8" } }, - "node_modules/braces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", - "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "node_modules/brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", "dev": true, + "license": "MIT", "dependencies": { - "fill-range": "^7.0.1" + "balanced-match": "^1.0.0" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" }, "engines": { "node": ">=8" @@ -1007,10 +1187,11 @@ } }, "node_modules/fill-range": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", - "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", "dev": true, + "license": "MIT", "dependencies": { "to-regex-range": "^5.0.1" }, @@ -1173,6 +1354,7 @@ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.12.0" } @@ -1251,12 +1433,13 @@ } }, "node_modules/micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "dev": true, + "license": "MIT", "dependencies": { - "braces": "^3.0.2", + "braces": "^3.0.3", "picomatch": "^2.3.1" }, "engines": { @@ -1290,6 +1473,22 @@ "node": ">=4" } }, + "node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/normalize-url": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", @@ -1518,10 +1717,14 @@ } }, "node_modules/rollup": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.2.0.tgz", - "integrity": "sha512-deaMa9Z+jPVeBD2dKXv+h7EbdKte9++V2potc/ADqvVgEr6DEJ3ia9u0joarjC2lX/ubaCRYz3QVx0TzuVqAJA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.53.2.tgz", + "integrity": "sha512-MHngMYwGJVi6Fmnk6ISmnk7JAHRNF0UkuucA0CUW3N3a4KnONPEZz+vUanQP/ZC/iY1Qkf3bwPWzyY84wEks1g==", "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, "bin": { "rollup": "dist/bin/rollup" }, @@ -1530,18 +1733,28 @@ "npm": ">=8.0.0" }, "optionalDependencies": { - "@rollup/rollup-android-arm-eabi": "4.2.0", - "@rollup/rollup-android-arm64": "4.2.0", - "@rollup/rollup-darwin-arm64": "4.2.0", - "@rollup/rollup-darwin-x64": "4.2.0", - "@rollup/rollup-linux-arm-gnueabihf": "4.2.0", - "@rollup/rollup-linux-arm64-gnu": "4.2.0", - "@rollup/rollup-linux-arm64-musl": "4.2.0", - "@rollup/rollup-linux-x64-gnu": "4.2.0", - "@rollup/rollup-linux-x64-musl": "4.2.0", - "@rollup/rollup-win32-arm64-msvc": "4.2.0", - "@rollup/rollup-win32-ia32-msvc": "4.2.0", - "@rollup/rollup-win32-x64-msvc": "4.2.0", + "@rollup/rollup-android-arm-eabi": "4.53.2", + "@rollup/rollup-android-arm64": "4.53.2", + "@rollup/rollup-darwin-arm64": "4.53.2", + "@rollup/rollup-darwin-x64": "4.53.2", + "@rollup/rollup-freebsd-arm64": "4.53.2", + "@rollup/rollup-freebsd-x64": "4.53.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.53.2", + "@rollup/rollup-linux-arm-musleabihf": "4.53.2", + "@rollup/rollup-linux-arm64-gnu": "4.53.2", + "@rollup/rollup-linux-arm64-musl": "4.53.2", + "@rollup/rollup-linux-loong64-gnu": "4.53.2", + "@rollup/rollup-linux-ppc64-gnu": "4.53.2", + "@rollup/rollup-linux-riscv64-gnu": "4.53.2", + "@rollup/rollup-linux-riscv64-musl": "4.53.2", + "@rollup/rollup-linux-s390x-gnu": "4.53.2", + "@rollup/rollup-linux-x64-gnu": "4.53.2", + "@rollup/rollup-linux-x64-musl": "4.53.2", + "@rollup/rollup-openharmony-arm64": "4.53.2", + "@rollup/rollup-win32-arm64-msvc": "4.53.2", + "@rollup/rollup-win32-ia32-msvc": "4.53.2", + "@rollup/rollup-win32-x64-gnu": "4.53.2", + "@rollup/rollup-win32-x64-msvc": "4.53.2", "fsevents": "~2.3.2" } }, @@ -1778,6 +1991,7 @@ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, + "license": "MIT", "dependencies": { "is-number": "^7.0.0" }, @@ -1908,86 +2122,156 @@ } }, "@rollup/rollup-android-arm-eabi": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.2.0.tgz", - "integrity": "sha512-8PlggAxGxavr+pkCNeV1TM2wTb2o+cUWDg9M1cm9nR27Dsn287uZtSLYXoQqQcmq+sYfF7lHfd3sWJJinH9GmA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.53.2.tgz", + "integrity": "sha512-yDPzwsgiFO26RJA4nZo8I+xqzh7sJTZIWQOxn+/XOdPE31lAvLIYCKqjV+lNH/vxE2L2iH3plKxDCRK6i+CwhA==", "dev": true, "optional": true }, "@rollup/rollup-android-arm64": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.2.0.tgz", - "integrity": "sha512-+71T85hbMFrJI+zKQULNmSYBeIhru55PYoF/u75MyeN2FcxE4HSPw20319b+FcZ4lWx2Nx/Ql9tN+hoaD3GH/A==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.53.2.tgz", + "integrity": "sha512-k8FontTxIE7b0/OGKeSN5B6j25EuppBcWM33Z19JoVT7UTXFSo3D9CdU39wGTeb29NO3XxpMNauh09B+Ibw+9g==", "dev": true, "optional": true }, "@rollup/rollup-darwin-arm64": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.2.0.tgz", - "integrity": "sha512-IIIQLuG43QIElT1JZqUP/zqIdiJl4t9U/boa0GZnQTw9m1X0k3mlBuysbgYXeloLT1RozdL7bgw4lpSaI8GOXw==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.53.2.tgz", + "integrity": "sha512-A6s4gJpomNBtJ2yioj8bflM2oogDwzUiMl2yNJ2v9E7++sHrSrsQ29fOfn5DM/iCzpWcebNYEdXpaK4tr2RhfQ==", "dev": true, "optional": true }, "@rollup/rollup-darwin-x64": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.2.0.tgz", - "integrity": "sha512-BXcXvnLaea1Xz900omrGJhxHFJfH9jZ0CpJuVsbjjhpniJ6qiLXz3xA8Lekaa4MuhFcJd4f0r+Ky1G4VFbYhWw==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.53.2.tgz", + "integrity": "sha512-e6XqVmXlHrBlG56obu9gDRPW3O3hLxpwHpLsBJvuI8qqnsrtSZ9ERoWUXtPOkY8c78WghyPHZdmPhHLWNdAGEw==", + "dev": true, + "optional": true + }, + "@rollup/rollup-freebsd-arm64": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.53.2.tgz", + "integrity": "sha512-v0E9lJW8VsrwPux5Qe5CwmH/CF/2mQs6xU1MF3nmUxmZUCHazCjLgYvToOk+YuuUqLQBio1qkkREhxhc656ViA==", + "dev": true, + "optional": true + }, + "@rollup/rollup-freebsd-x64": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.53.2.tgz", + "integrity": "sha512-ClAmAPx3ZCHtp6ysl4XEhWU69GUB1D+s7G9YjHGhIGCSrsg00nEGRRZHmINYxkdoJehde8VIsDC5t9C0gb6yqA==", "dev": true, "optional": true }, "@rollup/rollup-linux-arm-gnueabihf": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.2.0.tgz", - "integrity": "sha512-f4K3MKw9Y4AKi4ANGnmPIglr+S+8tO858YrGVuqAHXxJdVghBmz9CPU9kDpOnGvT4g4vg5uNyIFpOOFvffXyMA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.53.2.tgz", + "integrity": "sha512-EPlb95nUsz6Dd9Qy13fI5kUPXNSljaG9FiJ4YUGU1O/Q77i5DYFW5KR8g1OzTcdZUqQQ1KdDqsTohdFVwCwjqg==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-arm-musleabihf": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.53.2.tgz", + "integrity": "sha512-BOmnVW+khAUX+YZvNfa0tGTEMVVEerOxN0pDk2E6N6DsEIa2Ctj48FOMfNDdrwinocKaC7YXUZ1pHlKpnkja/Q==", "dev": true, "optional": true }, "@rollup/rollup-linux-arm64-gnu": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.2.0.tgz", - "integrity": "sha512-bNsTYQBgp4H7w6cT7FZhesxpcUPahsSIy4NgdZjH1ZwEoZHxi4XKglj+CsSEkhsKi+x6toVvMylhjRKhEMYfnA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.53.2.tgz", + "integrity": "sha512-Xt2byDZ+6OVNuREgBXr4+CZDJtrVso5woFtpKdGPhpTPHcNG7D8YXeQzpNbFRxzTVqJf7kvPMCub/pcGUWgBjA==", "dev": true, "optional": true }, "@rollup/rollup-linux-arm64-musl": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.2.0.tgz", - "integrity": "sha512-Jp1NxBJpGLuxRU2ihrQk4IZ+ia5nffobG6sOFUPW5PMYkF0kQtxEbeDuCa69Xif211vUOcxlOnf5IOEIpTEySA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.53.2.tgz", + "integrity": "sha512-+LdZSldy/I9N8+klim/Y1HsKbJ3BbInHav5qE9Iy77dtHC/pibw1SR/fXlWyAk0ThnpRKoODwnAuSjqxFRDHUQ==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-loong64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.53.2.tgz", + "integrity": "sha512-8ms8sjmyc1jWJS6WdNSA23rEfdjWB30LH8Wqj0Cqvv7qSHnvw6kgMMXRdop6hkmGPlyYBdRPkjJnj3KCUHV/uQ==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-ppc64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.53.2.tgz", + "integrity": "sha512-3HRQLUQbpBDMmzoxPJYd3W6vrVHOo2cVW8RUo87Xz0JPJcBLBr5kZ1pGcQAhdZgX9VV7NbGNipah1omKKe23/g==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-riscv64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.53.2.tgz", + "integrity": "sha512-fMjKi+ojnmIvhk34gZP94vjogXNNUKMEYs+EDaB/5TG/wUkoeua7p7VCHnE6T2Tx+iaghAqQX8teQzcvrYpaQA==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-riscv64-musl": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.53.2.tgz", + "integrity": "sha512-XuGFGU+VwUUV5kLvoAdi0Wz5Xbh2SrjIxCtZj6Wq8MDp4bflb/+ThZsVxokM7n0pcbkEr2h5/pzqzDYI7cCgLQ==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-s390x-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.53.2.tgz", + "integrity": "sha512-w6yjZF0P+NGzWR3AXWX9zc0DNEGdtvykB03uhonSHMRa+oWA6novflo2WaJr6JZakG2ucsyb+rvhrKac6NIy+w==", "dev": true, "optional": true }, "@rollup/rollup-linux-x64-gnu": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.2.0.tgz", - "integrity": "sha512-3p3iRtQmv2aXw+vtKNyZMLOQ+LSRsqArXjKAh2Oj9cqwfIRe7OXvdkOzWfZOIp1F/x5KJzVAxGxnniF4cMbnsQ==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.53.2.tgz", + "integrity": "sha512-yo8d6tdfdeBArzC7T/PnHd7OypfI9cbuZzPnzLJIyKYFhAQ8SvlkKtKBMbXDxe1h03Rcr7u++nFS7tqXz87Gtw==", "dev": true, "optional": true }, "@rollup/rollup-linux-x64-musl": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.2.0.tgz", - "integrity": "sha512-atih7IF/reUZe4LBLC5Izd44hth2tfDIG8LaPp4/cQXdHh9jabcZEvIeRPrpDq0i/Uu487Qu5gl5KwyAnWajnw==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.53.2.tgz", + "integrity": "sha512-ah59c1YkCxKExPP8O9PwOvs+XRLKwh/mV+3YdKqQ5AMQ0r4M4ZDuOrpWkUaqO7fzAHdINzV9tEVu8vNw48z0lA==", + "dev": true, + "optional": true + }, + "@rollup/rollup-openharmony-arm64": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.53.2.tgz", + "integrity": "sha512-4VEd19Wmhr+Zy7hbUsFZ6YXEiP48hE//KPLCSVNY5RMGX2/7HZ+QkN55a3atM1C/BZCGIgqN+xrVgtdak2S9+A==", "dev": true, "optional": true }, "@rollup/rollup-win32-arm64-msvc": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.2.0.tgz", - "integrity": "sha512-vYxF3tKJeUE4ceYzpNe2p84RXk/fGK30I8frpRfv/MyPStej/mRlojztkN7Jtd1014HHVeq/tYaMBz/3IxkxZw==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.53.2.tgz", + "integrity": "sha512-IlbHFYc/pQCgew/d5fslcy1KEaYVCJ44G8pajugd8VoOEI8ODhtb/j8XMhLpwHCMB3yk2J07ctup10gpw2nyMA==", "dev": true, "optional": true }, "@rollup/rollup-win32-ia32-msvc": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.2.0.tgz", - "integrity": "sha512-1LZJ6zpl93SaPQvas618bMFarVwufWTaczH4ESAbFcwiC4OtznA6Ym+hFPyIGaJaGEB8uMWWac0uXGPXOg5FGA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.53.2.tgz", + "integrity": "sha512-lNlPEGgdUfSzdCWU176ku/dQRnA7W+Gp8d+cWv73jYrb8uT7HTVVxq62DUYxjbaByuf1Yk0RIIAbDzp+CnOTFg==", + "dev": true, + "optional": true + }, + "@rollup/rollup-win32-x64-gnu": { + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.53.2.tgz", + "integrity": "sha512-S6YojNVrHybQis2lYov1sd+uj7K0Q05NxHcGktuMMdIQ2VixGwAfbJ23NnlvvVV1bdpR2m5MsNBViHJKcA4ADw==", "dev": true, "optional": true }, "@rollup/rollup-win32-x64-msvc": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.2.0.tgz", - "integrity": "sha512-dgQfFdHCNg08nM5zBmqxqc9vrm0DVzhWotpavbPa0j4//MAOKZEB75yGAfzQE9fUJ+4pvM1239Y4IhL8f6sSog==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.53.2.tgz", + "integrity": "sha512-k+/Rkcyx//P6fetPoLMb8pBeqJBNGx81uuf7iljX9++yNBVRDQgD04L+SVXmXmh5ZP4/WOp4mWF0kmi06PW2tA==", "dev": true, "optional": true }, @@ -1998,14 +2282,15 @@ "dev": true }, "@swc/cli": { - "version": "0.1.62", - "resolved": "https://registry.npmjs.org/@swc/cli/-/cli-0.1.62.tgz", - "integrity": "sha512-kOFLjKY3XH1DWLfXL1/B5MizeNorHR8wHKEi92S/Zi9Md/AK17KSqR8MgyRJ6C1fhKHvbBCl8wboyKAFXStkYw==", + "version": "0.1.65", + "resolved": "https://registry.npmjs.org/@swc/cli/-/cli-0.1.65.tgz", + "integrity": "sha512-4NcgsvJVHhA7trDnMmkGLLvWMHu2kSy+qHx6QwRhhJhdiYdNUrhdp+ERxen73sYtaeEOYeLJcWrQ60nzKi6rpg==", "dev": true, "requires": { "@mole-inc/bin-wrapper": "^8.0.1", "commander": "^7.1.0", "fast-glob": "^3.2.5", + "minimatch": "^9.0.3", "semver": "^7.3.8", "slash": "3.0.0", "source-map": "^0.7.3" @@ -2140,6 +2425,12 @@ "@types/responselike": "^1.0.0" } }, + "@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true + }, "@types/http-cache-semantics": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.3.tgz", @@ -2179,6 +2470,12 @@ "integrity": "sha512-Of/R0wqp83cgHozfIYLbBMnej79U/SVGOOyuB3VVFv1NRM/PSFMK12x9KVtiYzJqmnU5WR2qp0Z5rHb7sWGnFQ==", "dev": true }, + "balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, "bin-check": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/bin-check/-/bin-check-4.1.0.tgz", @@ -2200,9 +2497,9 @@ }, "dependencies": { "cross-spawn": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", - "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "dev": true, "requires": { "path-key": "^3.1.0", @@ -2291,13 +2588,22 @@ "semver-truncate": "^3.0.0" } }, - "braces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", - "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", "dev": true, "requires": { - "fill-range": "^7.0.1" + "balanced-match": "^1.0.0" + } + }, + "braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "requires": { + "fill-range": "^7.1.1" } }, "cacheable-lookup": { @@ -2499,9 +2805,9 @@ } }, "fill-range": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", - "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", "dev": true, "requires": { "to-regex-range": "^5.0.1" @@ -2674,12 +2980,12 @@ "dev": true }, "micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "dev": true, "requires": { - "braces": "^3.0.2", + "braces": "^3.0.3", "picomatch": "^2.3.1" } }, @@ -2701,6 +3007,15 @@ "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", "dev": true }, + "minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dev": true, + "requires": { + "brace-expansion": "^2.0.1" + } + }, "normalize-url": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", @@ -2849,23 +3164,34 @@ "dev": true }, "rollup": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.2.0.tgz", - "integrity": "sha512-deaMa9Z+jPVeBD2dKXv+h7EbdKte9++V2potc/ADqvVgEr6DEJ3ia9u0joarjC2lX/ubaCRYz3QVx0TzuVqAJA==", + "version": "4.53.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.53.2.tgz", + "integrity": "sha512-MHngMYwGJVi6Fmnk6ISmnk7JAHRNF0UkuucA0CUW3N3a4KnONPEZz+vUanQP/ZC/iY1Qkf3bwPWzyY84wEks1g==", "dev": true, "requires": { - "@rollup/rollup-android-arm-eabi": "4.2.0", - "@rollup/rollup-android-arm64": "4.2.0", - "@rollup/rollup-darwin-arm64": "4.2.0", - "@rollup/rollup-darwin-x64": "4.2.0", - "@rollup/rollup-linux-arm-gnueabihf": "4.2.0", - "@rollup/rollup-linux-arm64-gnu": "4.2.0", - "@rollup/rollup-linux-arm64-musl": "4.2.0", - "@rollup/rollup-linux-x64-gnu": "4.2.0", - "@rollup/rollup-linux-x64-musl": "4.2.0", - "@rollup/rollup-win32-arm64-msvc": "4.2.0", - "@rollup/rollup-win32-ia32-msvc": "4.2.0", - "@rollup/rollup-win32-x64-msvc": "4.2.0", + "@rollup/rollup-android-arm-eabi": "4.53.2", + "@rollup/rollup-android-arm64": "4.53.2", + "@rollup/rollup-darwin-arm64": "4.53.2", + "@rollup/rollup-darwin-x64": "4.53.2", + "@rollup/rollup-freebsd-arm64": "4.53.2", + "@rollup/rollup-freebsd-x64": "4.53.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.53.2", + "@rollup/rollup-linux-arm-musleabihf": "4.53.2", + "@rollup/rollup-linux-arm64-gnu": "4.53.2", + "@rollup/rollup-linux-arm64-musl": "4.53.2", + "@rollup/rollup-linux-loong64-gnu": "4.53.2", + "@rollup/rollup-linux-ppc64-gnu": "4.53.2", + "@rollup/rollup-linux-riscv64-gnu": "4.53.2", + "@rollup/rollup-linux-riscv64-musl": "4.53.2", + "@rollup/rollup-linux-s390x-gnu": "4.53.2", + "@rollup/rollup-linux-x64-gnu": "4.53.2", + "@rollup/rollup-linux-x64-musl": "4.53.2", + "@rollup/rollup-openharmony-arm64": "4.53.2", + "@rollup/rollup-win32-arm64-msvc": "4.53.2", + "@rollup/rollup-win32-ia32-msvc": "4.53.2", + "@rollup/rollup-win32-x64-gnu": "4.53.2", + "@rollup/rollup-win32-x64-msvc": "4.53.2", + "@types/estree": "1.0.8", "fsevents": "~2.3.2" } }, diff --git a/package.json b/package.json index a8ef4d3..f20fb77 100644 --- a/package.json +++ b/package.json @@ -3,7 +3,7 @@ "version": "1.1.0", "description": "Flic Hub MQTT Server", "scripts": { - "build": "swc src/ -d dist/ && rollup dist/index.js --file lib.js -f cjs" + "build": "rm -rf dist/* && swc src/ -d dist/ && rollup dist/index.js --file lib.js -f cjs" }, "repository": { "type": "git", @@ -21,4 +21,4 @@ "rollup": "^4.2.0", "typescript": "^5.2.2" } -} \ No newline at end of file +} diff --git a/src/ButtonController.ts b/src/ButtonController.ts deleted file mode 100644 index 4153dbc..0000000 --- a/src/ButtonController.ts +++ /dev/null @@ -1,194 +0,0 @@ -import { HAComponent, HADevice, HAmqtt } from "./HAmqtt"; -import { makeLogger } from "./Logger"; -import { Button, ButtonModule } from "./flicTypes"; - -const ms2ISO8601 = (ms: number): string => - (new Date(ms)).toISOString().slice(0, 19).replace('T', ' ') - -export type ButtonControllerOpt = { - debug: boolean; -} -export const makeOptions = (opt: Partial): ButtonControllerOpt => ({ - debug: false, - ...opt, -}) -const ENTITIES: Record]> = { - "action": ['sensor', { icon: 'mdi:gesture-tap-button', name: "Click Action" }], - "state": ['sensor', { icon: 'mdi:radiobox-indeterminate-variant' }], - "battery": ['sensor', { expire_after: 5, unit_of_measurement: '%', device_class: 'battery' }], - "batteryLastUpdate": ['sensor', { entity_category: "diagnostic", expire_after: 5, name: "Battery Last Update Time", device_class: "duration", unit_of_measurement: "s" }], - "lifeline": ['binary_sensor', { entity_category: "diagnostic", expire_after: 5, name: "Flichub Connected", device_class: "connectivity", unit_of_measurement: "s", payload_not_available: "OFF" }], - "connected": ['binary_sensor', { entity_category: "diagnostic", expire_after: 5, device_class: 'connectivity', name: "Connection Established", payload_not_available: "OFF" }], - "ready": ['binary_sensor', { entity_category: "config", expire_after: 5, device_class: 'connectivity', name: "Connection Verified" }], - "activeDisconnect": ['binary_sensor', { entity_category: "config", expire_after: 5, name: "User Active Disconnect" }], - "passive": ['binary_sensor', { entity_category: "config", expire_after: 5, name: "Passive Mode" }], - "button_short_press": [ - 'device_automation', - { 'type': 'button_short_press', 'subtype': 'button_1', 'automation_type': 'trigger', 'payload': 'ON' } - ], - "button_long_press": [ - 'device_automation', - { 'type': 'button_long_press', 'subtype': 'button_1', 'automation_type': 'trigger', 'payload': 'ON' } - ], - "button_double_press": [ - 'device_automation', - { 'type': 'button_double_press', 'subtype': 'button_1', 'automation_type': 'trigger', 'payload': 'ON' } - ] -} -export type ButtonController = ReturnType; -export function makeButtonController( - ha: HAmqtt, - buttonModule: ButtonModule, - options: Partial = {}, -) { - options = makeOptions(options); - const logger = makeLogger('btnc', options.debug) - logger.info("Starting Flic ButtonController with", JSON.stringify(options, null, 4)); - - const getDeviceFromButton = (button: Button): HADevice => { - return { - name: button.name, - identifiers: [button.serialNumber, button.uuid], - manufacturer: 'Flic', - model: `v${button.flicVersion}_${button.color.trim().length > 0 ? button.color : 'white'}`, - sw: String(button.firmwareVersion), - hw: String(button.flicVersion), - configuration_url: "https://hubsdk.flic.io/", - } - } - const genButtonUniqueId = (bdaddr: string): string => bdaddr.replace(/:/g, '_') - const registerButton = (button: Button) => { - logger.info('Registering', JSON.stringify(button, null, 4)) - const haDevice = getDeviceFromButton(button); - Object.keys(ENTITIES).forEach(objectId => { - let avl: any = { - availability: [ - { - payload_available: 'ON', - payload_not_available: 'unavailable', - topic: ha.genFlicPrefix(genButtonUniqueId(button.bdaddr), 'ready') - }, - { - payload_available: 'ON', - payload_not_available: 'unavailable', - topic: ha.genFlicPrefix(genButtonUniqueId(button.bdaddr), 'lifeline') - }, - ], - availability_mode: 'all', - }; - if (objectId === 'lifeline') { - avl = {} - } - if (objectId === 'ready' || objectId == 'connected') { - avl.availability = [avl.availability[1]] - } - if (ENTITIES[objectId][0] === 'device_automation') { - avl = {} - } - ha.registerEntity( - `Button ${objectId}`, - ENTITIES[objectId][0], - genButtonUniqueId(button.bdaddr), - objectId, - haDevice, - { - ...ENTITIES[objectId][1], - ...avl - }, - ) - }); - } - const deregisterButton = (button: Button) => { - logger.info('Deregistering', JSON.stringify(button, null, 4)) - Object.keys(ENTITIES).forEach(objectId => { - ha.deregisterEntity( - ENTITIES[objectId][0], - genButtonUniqueId(button.bdaddr), - objectId, - ) - }); - } - const publishButtonState = (button: Button, state: 'released' | 'pressed') => { - ha.publishState(genButtonUniqueId(button.bdaddr), 'state', state); - } - const publishButtonAction = (button: Button, state: 'click' | 'double_click' | 'hold') => { - ha.publishState(genButtonUniqueId(button.bdaddr), 'action', state); - if (state === 'click') { - ha.publishState(genButtonUniqueId(button.bdaddr), 'button_short_press', 'ON') - } else if (state === 'double_click') { - ha.publishState(genButtonUniqueId(button.bdaddr), 'button_double_press', 'ON') - } else if (state === 'hold') { - ha.publishState(genButtonUniqueId(button.bdaddr), 'button_long_press', 'ON') - } - } - const publishButtonMeta = (button: Button) => { - ha.publishState(genButtonUniqueId(button.bdaddr), 'battery', button.batteryStatus); - ha.publishState(genButtonUniqueId(button.bdaddr), 'batteryLastUpdate', button.batteryTimestamp ? `${Math.round((Date.now() - button.batteryTimestamp) / 1000)}` : 'unknown'); - ha.publishState(genButtonUniqueId(button.bdaddr), 'connected', button.connected ? 'ON' : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), 'ready', button.ready ? 'ON' : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), 'activeDisconnect', button.activeDisconnect ? 'ON' : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), 'passive', button.activeDisconnect ? 'ON' : "OFF"); - ha.publishState(genButtonUniqueId(button.bdaddr), 'lifeline', 'ON'); - } - const addBtn = (eventName: string) => (obj: { bdaddr: string }) => { - const button = buttonModule.getButton(obj.bdaddr); - logger.info(eventName, "upserting", button.name, genButtonUniqueId(button.bdaddr)); - registerButton(button); - } - const start = () => { - logger.info("Starting...") - let resetActiontInv: null | any = null; - buttonModule.on('buttonAdded', addBtn('buttonAdded')); - buttonModule.on('buttonConnected', addBtn('buttonConnected')); - buttonModule.on('buttonReady', (btn) => { - addBtn('buttonReady')(btn); - const button = buttonModule.getButton(btn.bdaddr); - publishButtonState(button, 'released') - publishButtonAction(button, 'none') - }); - buttonModule.on('buttonUpdated', addBtn('buttonUpdated')); - buttonModule.on('buttonDeleted', (btn) => { - logger.debug('buttonDeleted', JSON.stringify(btn, null, 4)) - deregisterButton(btn); - publishButtonMeta(btn); - }); - buttonModule.on('buttonDisconnected', ({ bdaddr }) => { - publishButtonMeta(buttonModule.getButton(bdaddr)); - }); - buttonModule.on('buttonDown', ({ bdaddr }) => { - const btn = buttonModule.getButton(bdaddr); - publishButtonState(btn, 'pressed'); - publishButtonMeta(btn); - }); - buttonModule.on('buttonUp', ({ bdaddr }) => { - const btn = buttonModule.getButton(bdaddr); - publishButtonState(btn, 'released'); - publishButtonMeta(btn); - }); - buttonModule.on('buttonSingleOrDoubleClickOrHold', obj => { - if (resetActiontInv !== null) { - clearTimeout(resetActiontInv); - } - const btn = buttonModule.getButton(obj.bdaddr); - publishButtonAction( - btn, - obj.isSingleClick ? "click" : obj.isDoubleClick ? "double_click" : "hold", - ); - publishButtonMeta(btn); - resetActiontInv = setTimeout(() => { - publishButtonAction(btn, 'none'); - }, 500) - }); - logger.info("Registering all buttons...") - buttonModule.getButtons().forEach(registerButton); - setInterval(() => buttonModule.getButtons().forEach(publishButtonMeta), 3000); - logger.info('is up') - } - - return { - start, - publishButtonAction, - publishButtonMeta, - publishButtonState, - } -} \ No newline at end of file diff --git a/src/HAmqtt.ts b/src/HAmqtt.ts deleted file mode 100644 index c9edefe..0000000 --- a/src/HAmqtt.ts +++ /dev/null @@ -1,98 +0,0 @@ -import { makeLogger } from "./Logger"; -import { MQTT } from "./mqtt"; - -export type HAmqttOptions = { - debug: boolean, - topics: { - homeassistant: string, - flic: string, - } -} -export type MQTTPublishOpt = { - retain?: boolean // the server should retain this message and send it out again to new subscribers - dup?: boolean // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) -} -export type HADevice = { - name: string, - identifiers: string[], - manufacturer: string, - model: string, - sw?: string, - hw?: string, - configuration_url?: string, -} -export type HAComponent = 'sensor' | 'binary_sensor' | 'button' | 'switch' | 'text' | 'device_automation'; -export const makeOptions = (opt: Partial): HAmqttOptions => ({ - debug: false, - ...opt, - topics: { - homeassistant: 'homeassistant', - flic: 'flic', - ...opt.topics, - } -}) -export type HAmqtt = ReturnType; -export function makeHAmqtt( - mqttServer: MQTT, - options: Partial = {}, -) { - options = makeOptions(options); - const logger = makeLogger('mqtt:ha', options.debug); - logger.info("starting...", JSON.stringify(options, null, 4)); - - const genFlicPrefix = (nodeId: string, objectId: string): string => { - return `${options.topics.flic}/${nodeId}/${objectId}` - } - - const genHAPrefix = (component: HAComponent, nodeId: string, objectId: string) => { - return `${options.topics.homeassistant}/${component}/${nodeId}/${objectId}` - } - - const publishState = (nodeId: string, objectId: string, state: any, opt: MQTTPublishOpt = {}) => { - const btntopic = genFlicPrefix(nodeId, objectId); - mqttServer.publish(btntopic, state + "", opt); - logger.debug(btntopic, state, JSON.stringify(opt)) - } - const registerEntity = ( - name: string, - component: HAComponent, - nodeId: string, - objectId: string, - device: HADevice, - additionalProps: Record = {}, - ) => { - const configtopic = genHAPrefix(component, nodeId, objectId) + "/config" - if (component === 'device_automation') { - additionalProps.topic = genFlicPrefix(nodeId, objectId) - } else { - additionalProps.state_topic = genFlicPrefix(nodeId, objectId) - } - const configObj = { - name, - ...additionalProps, - unique_id: `Flic_${nodeId}_${objectId}`, - device, - }; - mqttServer.publish(configtopic, JSON.stringify(configObj), { - retain: true, - }); - logger.debug(configtopic, JSON.stringify(configObj, null, 4)); - } - - const deregisterEntity = ( - component: HAComponent, - nodeId: string, - objectId: string, - ) => { - const configtopic = genHAPrefix(component, nodeId, objectId) + "/config" - mqttServer.publish(configtopic, null, { retain: false }); - logger.debug(configtopic, null); - } - - return { - deregisterEntity, - registerEntity, - publishState, - genFlicPrefix, - } -} \ No newline at end of file diff --git a/src/IRController.ts b/src/IRController.ts deleted file mode 100644 index 99fc5d6..0000000 --- a/src/IRController.ts +++ /dev/null @@ -1,176 +0,0 @@ -import { HADevice, HAmqtt } from "./HAmqtt"; -import { makeLogger } from "./Logger"; -import { IRModule } from "./flicTypes"; -import { MQTT } from "./mqtt"; - -const NODE_ID = 'FlicHubIR'; -const convertUint32Array2Str = (arr: Uint32Array): string => { - let outStr = [] - for (let i = 0; i < arr.length; i++) { - outStr.push(arr[i].toString(32)) - } - return outStr.join('_') -} -const convertStr2Uint32Array = (s: string): Uint32Array => { - const a = s.split('_'); - return new Uint32Array(a.slice(0, a.length - 2).map(v => parseInt(v, 32))) -} -export type IRControllerOpt = { - uniqueId: string, - debug: boolean; -} -export const makeOptions = (opt: Partial): IRControllerOpt => ({ - debug: false, - uniqueId: "0", - ...opt, -}) -export const makeIRController = ( - ir: IRModule, - ha: HAmqtt, - mqtt: MQTT, - options: Partial = {}, -) => { - options = makeOptions(options); - const logger = makeLogger('ir', options.debug); - const haDevice: HADevice = { - name: 'IR', - manufacturer: 'Flic', - model: `${NODE_ID}${options.uniqueId}`, - identifiers: ['FlicHubIR'], - configuration_url: "https://hubsdk.flic.io/", - } - const nodeId = `${NODE_ID}${options.uniqueId}`; - const LIFELINE_SGINAL = ha.genFlicPrefix(nodeId, 'lifeline'); - const RECORD_SIGNAL_SET = ha.genFlicPrefix(nodeId, 'record/set'); - const VALUE_SIGNAL_SET = ha.genFlicPrefix(nodeId, 'signal/set'); - const VALUE_SIGNAL_STATE = ha.genFlicPrefix(nodeId, 'signal'); - const PLAY_SIGNAL_SET = ha.genFlicPrefix(nodeId, 'play/set'); - const availability = [ - { - "payload_available": "ON", - "payload_not_available": "unavailable", - "topic": LIFELINE_SGINAL, - } - ] - let currentSignal: string | null = null; - - const set_topics = [ - RECORD_SIGNAL_SET, - VALUE_SIGNAL_SET, - PLAY_SIGNAL_SET, - VALUE_SIGNAL_STATE, - ]; - - return { - start() { - logger.info('starting...') - logger.debug('setting up entities...') - ha.registerEntity( - 'IR Available', - 'binary_sensor', - nodeId, - 'lifeline', - haDevice, - { - device_class: 'connectivity', - expire_after: 5, - off_delay: 3, - entity_category: "diagnostic", - payload_available: "ON", - payload_not_available: "OFF", - } - ) - ha.registerEntity( - 'Record Signal', - 'switch', - nodeId, - 'record', - haDevice, - { - icon: 'mdi:record-rec', - command_topic: RECORD_SIGNAL_SET, - device_class: 'switch', - availability, - } - ) - ha.registerEntity( - 'Signal', - 'text', - nodeId, - 'signal', - haDevice, - { - command_topic: VALUE_SIGNAL_SET, - icon: 'mdi:broadcast', - max: 255, - availability, - } - ) - ha.registerEntity( - 'Play Signal', - 'button', - nodeId, - 'play', - haDevice, - { - icon: 'mdi:play', - command_topic: PLAY_SIGNAL_SET, - availability, - } - ) - logger.debug('setting default states....') - ha.publishState(nodeId, 'record', 'OFF') - ha.publishState(nodeId, 'play', 'OFF') - logger.debug('registering events') - mqtt.on('message', (topic, message) => { - logger.debug('message:', JSON.stringify({ topic, message })) - if (topic === RECORD_SIGNAL_SET) { - logger.debug('starting record') - ir.record() - ha.publishState(nodeId, 'record', 'ON') - } else if (topic === PLAY_SIGNAL_SET) { - if (currentSignal !== null) { - logger.info('playing', currentSignal) - let arr: Uint32Array | null = null - try { - arr = convertStr2Uint32Array(currentSignal) - } catch (err) { - logger.error('invalid string signal set', JSON.stringify(err), err) - return - } - ir.play(arr, (err) => { - if (err) { - logger.error('failed to play signal', JSON.stringify(err), err) - } else { - logger.debug('signal played!') - } - }) - } else { - logger.error('cannot play an unset signal') - } - } else if (topic === VALUE_SIGNAL_STATE) { - currentSignal = message - logger.info('setting currentSignal', currentSignal) - } else if (topic === VALUE_SIGNAL_SET) { - ha.publishState(nodeId, 'signal', message, { retain: true }) - } - }) - ir.on('recordComplete', data => { - const stringMessage = convertUint32Array2Str(data) - logger.debug('recording completed with', JSON.stringify({ data, stringMessage, rev: convertStr2Uint32Array(stringMessage) })) - if (stringMessage.length > 255) { - logger.error("stringMessage is too big! size=", stringMessage.length, 'max=255') - } - ha.publishState(nodeId, 'signal', stringMessage, { retain: true }) - ha.publishState(nodeId, 'record', 'OFF') - }) - - logger.debug('subscribing to', set_topics) - mqtt.subscribe(set_topics) - setInterval(() => { - ha.publishState(nodeId, 'lifeline', 'ON') - }, 2500) - logger.info('is up') - } - } -} \ No newline at end of file diff --git a/src/button_controller/button_state_handler.ts b/src/button_controller/button_state_handler.ts new file mode 100644 index 0000000..47ae9fb --- /dev/null +++ b/src/button_controller/button_state_handler.ts @@ -0,0 +1,118 @@ +import buttonModule, { Button } from "buttons"; +import { HAmqtt } from "../ha_mqtt/index"; +import { Logger } from "../Logger"; +import { genButtonUniqueId, getDeviceFromButton } from "./utils"; +import { ENTITIES } from "./entities"; + +export const ButtonStateHandler = (ha: HAmqtt, logger: Logger) => { + const registerButton = (button: Button) => { + logger.info("Registering", JSON.stringify(button, null, 4)); + const haDevice = getDeviceFromButton(button); + const uniqId = genButtonUniqueId(button.bdaddr); + ha.startLifeLine("Button Controller Connected", uniqId, haDevice); + Object.keys(ENTITIES).forEach((objectId) => { + let avl: any = { + availability: [ + { + payload_available: "ON", + payload_not_available: "unavailable", + topic: ha.genFlicPrefix(genButtonUniqueId(button.bdaddr), "ready"), + }, + { + payload_available: "ON", + payload_not_available: "unavailable", + topic: ha.genFlicPrefix( + genButtonUniqueId(button.bdaddr), + "lifeline", + ), + }, + ], + availability_mode: "all", + }; + if (objectId === "ready" || objectId == "connected") { + avl.availability = [avl.availability[1]]; + } + if (ENTITIES[objectId][0] === "device_automation") { + avl = {}; + } + ha.registerEntity( + `Button ${objectId}`, + ENTITIES[objectId][0], + uniqId, + objectId, + haDevice, + { + ...ENTITIES[objectId][1], + ...avl, + }, + ); + }); + }; + const deregisterButton = (bdaddr: string) => { + const uniqId = genButtonUniqueId(bdaddr); + logger.info("Deregistering", JSON.stringify({ bdaddr, uniqId }, null, 4)); + Object.keys(ENTITIES).forEach((objectId) => { + ha.deregisterEntity(ENTITIES[objectId][0], uniqId, objectId); + }); + }; + const publishButtonState = ( + bdaddr: string, + state: "released" | "pressed", + ) => { + logger.debug(`Updating state for bdaddr="${bdaddr}" state=${state}`); + ha.publishState(genButtonUniqueId(bdaddr), "state", state); + }; + const publishButtonAction = ( + bdaddr: string, + state: "click" | "double_click" | "hold" | "none", + ) => { + const uniqId = genButtonUniqueId(bdaddr); + ha.publishState(uniqId, "action", state); + logger.debug( + `Publishing click for bdaddr="${bdaddr}" uniqId="${uniqId}" state=${state}`, + ); + if (state === "click") { + ha.publishState(uniqId, "button_short_press", "ON"); + } else if (state === "double_click") { + ha.publishState(uniqId, "button_double_press", "ON"); + } else if (state === "hold") { + ha.publishState(uniqId, "button_long_press", "ON"); + } + }; + const publishButtonMeta = (bdaddr: string) => { + const button = buttonModule.getButton(bdaddr); + const uniqId = genButtonUniqueId(button.bdaddr); + ha.publishState(uniqId, "name", button.name); + ha.publishState(uniqId, "battery", button.batteryStatus); + ha.publishState(uniqId, "connected", button.connected ? "ON" : "OFF"); + ha.publishState(uniqId, "ready", button.ready ? "ON" : "OFF"); + ha.publishState( + uniqId, + "activeDisconnect", + button.activeDisconnect ? "ON" : "OFF", + ); + ha.publishState(uniqId, "passive", button.activeDisconnect ? "ON" : "OFF"); + ha.publishState(uniqId, "lifeline", "ON"); + }; + const handleBtnCreation = (eventName: string, obj: { bdaddr: string }) => { + const button = buttonModule.getButton(obj.bdaddr); + logger.info( + eventName, + "upserting", + button.name, + genButtonUniqueId(button.bdaddr), + ); + registerButton(button); + }; + return { + addBtn: (eventName: string) => (o: { bdaddr: string }) => + handleBtnCreation(eventName, o), + addBtnWithObject: (eventName: string) => (o: { button: Button }) => + handleBtnCreation(eventName, o.button), + publishButtonMeta, + publishButtonAction, + publishButtonState, + registerButton, + deregisterButton, + }; +}; diff --git a/src/button_controller/entities.ts b/src/button_controller/entities.ts new file mode 100644 index 0000000..29f27bb --- /dev/null +++ b/src/button_controller/entities.ts @@ -0,0 +1,73 @@ +export const ENTITIES: Record]> = { + name: [ + "sensor", + { + entity_category: "diagnostic", + name: "Button Name", + }, + ], + action: ["sensor", { icon: "mdi:gesture-tap-button", name: "Click Action" }], + state: ["sensor", { icon: "mdi:radiobox-indeterminate-variant" }], + battery: [ + "sensor", + { expire_after: 5, unit_of_measurement: "%", device_class: "battery" }, + ], + connected: [ + "binary_sensor", + { + entity_category: "diagnostic", + expire_after: 5, + device_class: "connectivity", + name: "Connection Established", + payload_not_available: "OFF", + }, + ], + ready: [ + "binary_sensor", + { + entity_category: "config", + expire_after: 5, + device_class: "connectivity", + name: "Connection Verified", + }, + ], + activeDisconnect: [ + "binary_sensor", + { + entity_category: "config", + expire_after: 5, + name: "User Active Disconnect", + }, + ], + passive: [ + "binary_sensor", + { entity_category: "config", expire_after: 5, name: "Passive Mode" }, + ], + button_short_press: [ + "device_automation", + { + type: "button_short_press", + subtype: "button_1", + automation_type: "trigger", + payload: "ON", + }, + ], + button_long_press: [ + "device_automation", + { + type: "button_long_press", + subtype: "button_1", + automation_type: "trigger", + payload: "ON", + }, + ], + button_double_press: [ + "device_automation", + { + type: "button_double_press", + subtype: "button_1", + automation_type: "trigger", + payload: "ON", + }, + ], +}; diff --git a/src/button_controller/index.ts b/src/button_controller/index.ts new file mode 100644 index 0000000..0cb448a --- /dev/null +++ b/src/button_controller/index.ts @@ -0,0 +1,93 @@ +import buttonModule from "buttons"; +import { HAmqtt } from "../ha_mqtt/index"; +import { makeLogger } from "../Logger"; +import { makeOptions } from "./options"; +import { ButtonStateHandler } from "./button_state_handler"; + +export type ButtonController = ReturnType; +export function makeButtonController( + ha: HAmqtt, + options: Partial = {}, +) { + options = makeOptions(options); + const logger = makeLogger("btnc", options.debug); + logger.info( + "Starting Flic ButtonController with", + JSON.stringify(options, null, 4), + ); + const stateHandler = ButtonStateHandler(ha, logger); + const setListeners = () => { + let resetActiontInv: null | any = null; + buttonModule.on( + "buttonAdded", + stateHandler.addBtnWithObject("buttonAdded"), + ); + buttonModule.on( + "buttonUpdated", + stateHandler.addBtnWithObject("buttonUpdated"), + ); + buttonModule.on("buttonDeleted", (btn) => { + logger.debug("buttonDeleted", JSON.stringify(btn, null, 4)); + stateHandler.deregisterButton(btn.bdaddr); + stateHandler.publishButtonMeta(btn.bdaddr); + }); + buttonModule.on("buttonConnected", stateHandler.addBtn("buttonConnected")); + buttonModule.on("buttonReady", (btn) => { + stateHandler.addBtn("buttonReady")(btn); + stateHandler.publishButtonState(btn.bdaddr, "released"); + stateHandler.publishButtonAction(btn.bdaddr, "none"); + }); + buttonModule.on("buttonDisconnected", ({ bdaddr }) => { + stateHandler.publishButtonMeta(bdaddr); + }); + buttonModule.on("buttonDown", ({ bdaddr }) => { + stateHandler.publishButtonState(bdaddr, "pressed"); + stateHandler.publishButtonMeta(bdaddr); + }); + buttonModule.on("buttonUp", ({ bdaddr }) => { + stateHandler.publishButtonState(bdaddr, "released"); + stateHandler.publishButtonMeta(bdaddr); + }); + buttonModule.on("buttonClickOrHold", (obj) => {}); + buttonModule.on("buttonSingleOrDoubleClickOrHold", (obj) => { + if (resetActiontInv !== null) { + clearTimeout(resetActiontInv); + } + stateHandler.publishButtonAction( + obj.bdaddr, + obj.isSingleClick + ? "click" + : obj.isDoubleClick + ? "double_click" + : "hold", + ); + stateHandler.publishButtonMeta(obj.bdaddr); + resetActiontInv = setTimeout(() => { + stateHandler.publishButtonAction(obj.bdaddr, "none"); + }, 500); + }); + }; + const start = () => { + logger.info("Starting..."); + logger.info("Setting listeners..."); + setListeners(); + logger.info("Registering all buttons..."); + buttonModule + .getButtons() + .forEach((btn) => stateHandler.registerButton(btn)); + setInterval(() => { + logger.debug("Updating button state!"); + buttonModule + .getButtons() + .forEach((btn) => stateHandler.publishButtonMeta(btn.bdaddr)); + }, 3000); + logger.info("is up"); + }; + + return { + start, + publishButtonAction: stateHandler.publishButtonAction, + publishButtonMeta: stateHandler.publishButtonMeta, + publishButtonState: stateHandler.publishButtonState, + }; +} diff --git a/src/button_controller/options.ts b/src/button_controller/options.ts new file mode 100644 index 0000000..9dc45ad --- /dev/null +++ b/src/button_controller/options.ts @@ -0,0 +1,6 @@ +export const makeOptions = ( + opt: Partial, +): ButtonControllerOpt => ({ + debug: false, + ...opt, +}); diff --git a/src/button_controller/utils.ts b/src/button_controller/utils.ts new file mode 100644 index 0000000..2634a26 --- /dev/null +++ b/src/button_controller/utils.ts @@ -0,0 +1,17 @@ +import { Button } from "buttons"; +import { HADevice } from "../ha_mqtt/index"; + +export const getDeviceFromButton = (button: Button): HADevice => { + return { + name: button.name, + identifiers: [button.serialNumber, button.uuid], + manufacturer: "Flic", + model: `v${button.flicVersion}_${button.color.trim().length > 0 ? button.color : "white"}`, + sw_version: String(button.firmwareVersion), + hw_version: String(button.flicVersion), + serial_number: String(button.serialNumber), + configuration_url: "https://hubsdk.flic.io/", + }; +}; +export const genButtonUniqueId = (bdaddr: string): string => + bdaddr.replace(/:/g, "_"); diff --git a/src/flicTypes.ts b/src/flicTypes.ts deleted file mode 100644 index 8ea6e80..0000000 --- a/src/flicTypes.ts +++ /dev/null @@ -1,40 +0,0 @@ - - -export type Button = { - bdaddr: string // Device address of button - serialNumber: string // Serial number - color: string // Colour of the button (lowercase) - name: string // The user assigned button name - activeDisconnect: boolean // The user has explicitly disconnected the button - connected: boolean // The connection to the button is currently established - ready: boolean // The connection is verified (see buttonReady) - batteryStatus: number | null // Battery level in percent (0-100), or null if unknown - batteryTimestamp: number | null // Last time the battery was updated - firmwareVersion: number | null // Firmware version of button, or null if unknown - flicVersion: number | null // Flic version (1 or 2) - uuid: string // A 32 characters long hex string, unique for every button - key: number | null // A 40 characters long hex string (only for Flic 2) -} - -export interface ButtonModule { - getButtons(): Button[], - getButton(bdaddr: string): Button, - on(ev: "buttonAdded", cb: (btn: Button) => void): void, - on(ev: "buttonUpdated", cb: (btn: Button) => void): void, - on(ev: "buttonDeleted", cb: (btn: Button) => void): void, - on(ev: "buttonConnected", cb: (btn: Button) => void): void, - on(ev: "buttonReady", cb: (obj: { bdaddr: string }) => void): void, - on(ev: "buttonDisconnected", cb: (obj: { bdaddr: string }) => void): void, - on(ev: "buttonDown", cb: (obj: { bdaddr: string }) => void): void, - on(ev: "buttonUp", cb: (obj: { bdaddr: string }) => void): void, - on(ev: "buttonClickOrHold", cb: (obj: { bdaddr: string, isClick: boolean, isHold: boolean }) => void): void, - on(ev: "buttonSingleOrDoubleClick", cb: (obj: { bdaddr: string, isSingleClick: boolean, isDoubleClick: boolean }) => void): void, - on(ev: "buttonSingleOrDoubleClickOrHold", cb: (obj: { bdaddr: string, isSingleClick: boolean, isDoubleClick: boolean, isHold: boolean }) => void): void, -} - -export interface IRModule { - record(): void; - cancelRecord(): void; - play(arr: Uint32Array, cb: (err: any | undefined) => void): void; - on(ev: 'recordComplete', cb: (d: Uint32Array) => void): void; -} \ No newline at end of file diff --git a/src/ha_mqtt/index.ts b/src/ha_mqtt/index.ts new file mode 100644 index 0000000..312e1b6 --- /dev/null +++ b/src/ha_mqtt/index.ts @@ -0,0 +1,109 @@ +import { makeLogger } from "../Logger"; +import { MQTT } from "../mqtt"; +import { makeOptions } from "./utils"; + +export type HAmqtt = ReturnType; +export function makeHAmqtt( + mqttServer: MQTT, + options: Partial = {}, +) { + options = makeOptions(options); + const logger = makeLogger("mqtt:ha", options.debug); + logger.info("starting...", JSON.stringify(options, null, 4)); + const genFlicPrefix = (nodeId: string, objectId: string): string => { + return `${options.topics.flic}/${nodeId}/${objectId}`; + }; + const genFlicPrefixObject = ( + nodeId: string, + objectId: string, + ): FlicMqttPrefix => ({ + nodeId, + objectId, + mqttPrefix: genFlicPrefix(nodeId, objectId), + }); + + const genHAPrefix = ( + component: HAComponent, + nodeId: string, + objectId: string, + ) => { + return `${options.topics.homeassistant}/${component}/${nodeId}/${objectId}`; + }; + + const publishState = ( + nodeId: string, + objectId: string, + state: any, + opt: MQTTPublishOpt = {}, + ) => { + const btntopic = genFlicPrefix(nodeId, objectId); + mqttServer.publish(btntopic, state + "", opt); + logger.debug(btntopic, state, JSON.stringify(opt)); + }; + const registerEntity = ( + name: string, + component: HAComponent, + nodeId: string, + objectId: string, + device: HADevice, + additionalProps: { + topic?: string; + state_topic?: string; + } & { + [key: string]: any; + } = {}, + ) => { + const configtopic = genHAPrefix(component, nodeId, objectId) + "/config"; + if (component === "device_automation") { + additionalProps.topic = genFlicPrefix(nodeId, objectId); + } else { + additionalProps.state_topic = genFlicPrefix(nodeId, objectId); + } + const configObj = { + name, + ...additionalProps, + unique_id: `Flic_${nodeId}_${objectId}`, + device, + }; + mqttServer.publish(configtopic, JSON.stringify(configObj), { + retain: true, + }); + logger.debug(configtopic, JSON.stringify(configObj, null, 4)); + }; + + const deregisterEntity = ( + component: HAComponent, + nodeId: string, + objectId: string, + ) => { + const configtopic = genHAPrefix(component, nodeId, objectId) + "/config"; + mqttServer.publish(configtopic, null, { retain: false }); + logger.debug(configtopic, null); + }; + const startLifeLine = ( + name: string, + nodeId: string, + haDevice: HADevice, + topic: string = "lifeline", + ) => { + registerEntity(name, "binary_sensor", nodeId, topic, haDevice, { + device_class: "connectivity", + expire_after: 5, + off_delay: 3, + entity_category: "diagnostic", + payload_available: "ON", + payload_not_available: "OFF", + }); + setInterval(() => { + publishState(nodeId, topic, "ON"); + }, 2500); + }; + return { + deregisterEntity, + registerEntity, + publishState, + genFlicPrefix, + genFlicPrefixObject, + startLifeLine, + }; +} diff --git a/src/ha_mqtt/utils.ts b/src/ha_mqtt/utils.ts new file mode 100644 index 0000000..b3b0b38 --- /dev/null +++ b/src/ha_mqtt/utils.ts @@ -0,0 +1,9 @@ +export const makeOptions = (opt: Partial): HAmqttOptions => ({ + debug: false, + ...opt, + topics: { + homeassistant: "homeassistant", + flic: "flic", + ...opt.topics, + }, +}); diff --git a/src/hub_controller/index.ts b/src/hub_controller/index.ts new file mode 100644 index 0000000..5fc6318 --- /dev/null +++ b/src/hub_controller/index.ts @@ -0,0 +1,65 @@ +import { HAmqtt } from "../ha_mqtt/index"; +import { makeLogger } from "../Logger"; +import { MQTT } from "../mqtt"; +import flichub from "flicapp"; +import { + makeOptions, + getHADevice, + getConstants, + FlicHubConstants, +} from "./utils"; +import { virtualDeviceUpdateHandler } from "./virtual_device_update"; + +export const startFlicHubController = ( + ha: HAmqtt, + mqtt: MQTT, + _options: Partial = {}, +) => { + const options = makeOptions(_options); + const logger = makeLogger("flichub", options.debug); + const haDevice = getHADevice(options); + const constants: FlicHubConstants = getConstants(ha, options); + const availability = [ + { + payload_available: "ON", + payload_not_available: "unavailable", + topic: constants.LIFELINE_SGINAL.mqttPrefix, + }, + ]; + + logger.info("starting..."); + logger.debug("setting up entities..."); + ha.startLifeLine( + "FlicHub Connected", + constants.NODE_ID, + haDevice, + constants.LIFELINE_SGINAL.objectId, + ); + ha.registerEntity( + "Action Message", + "sensor", + constants.NODE_ID, + constants.MESSAGE.objectId, + haDevice, + { + icon: "mdi:message", + availability, + }, + ); + ha.publishState(constants.NODE_ID, constants.MESSAGE.objectId, ""); + + flichub.on("actionMessage", (obj) => { + ha.publishState(constants.NODE_ID, constants.MESSAGE.objectId, obj); + }); + flichub.on("virtualDeviceUpdate", (update) => + virtualDeviceUpdateHandler( + ha, + logger, + haDevice, + constants.NODE_ID, + update, + constants.COMMAND_TOPIC(update.metaData.virtualDeviceId), + availability, + ), + ); +}; diff --git a/src/hub_controller/utils.ts b/src/hub_controller/utils.ts new file mode 100644 index 0000000..e5d4e8b --- /dev/null +++ b/src/hub_controller/utils.ts @@ -0,0 +1,31 @@ +import hubinfo from "hubinfo"; +import { HAmqtt } from "../ha_mqtt/index"; + +const NODE_ID = "FlicHub"; + +export const makeOptions = (opt: Partial): FlicHubOptions => ({ + debug: false, + uniqueId: "0", + ...opt, +}); +export const getHADevice = (options: FlicHubOptions): HADevice => ({ + name: `FlicHub (${options.uniqueId})`, + manufacturer: "Flic", + model: `${NODE_ID}${options.uniqueId}`, + identifiers: ["FlicHub"], + configuration_url: "https://hubsdk.flic.io/", + sw_version: hubinfo.firmwareVersion, + serial_number: hubinfo.serialNumber, +}); +export type FlicHubConstants = ReturnType; +export type FlicHubConstantsNames = keyof FlicHubConstants; +export const getConstants = (ha: HAmqtt, options: FlicHubOptions) => { + const nodeId = `${NODE_ID}${options.uniqueId}`; + return { + NODE_ID: nodeId, + LIFELINE_SGINAL: ha.genFlicPrefixObject(nodeId, "lifeline"), + MESSAGE: ha.genFlicPrefixObject(nodeId, "action-message"), + COMMAND_TOPIC: (virtualId: string) => + ha.genFlicPrefixObject(nodeId, `virt-command-${virtualId}`), + }; +}; diff --git a/src/hub_controller/virtual_device_update.ts b/src/hub_controller/virtual_device_update.ts new file mode 100644 index 0000000..940ca5f --- /dev/null +++ b/src/hub_controller/virtual_device_update.ts @@ -0,0 +1,60 @@ +import { + VirtualDeviceMetaData, + VirtualDeviceType, + VirtualDeviceUpdate, +} from "flicapp"; +import { HAmqtt } from "../ha_mqtt/index"; +import { Logger } from "../Logger"; + +const genVirtualDeviceObjectId = ({ + virtualDeviceId, + dimmableType, +}: VirtualDeviceMetaData) => + `virt-${dimmableType}-${virtualDeviceId}`.toLowerCase(); + +const VirtualDeviceType2HAComponent: Record = { + Blind: "cover", + Light: "light", + Speaker: "media_player", +}; + +const convertStateUpdate2HA = (update: VirtualDeviceUpdate) => { + if (update.metaData.dimmableType === "Light") { + if (update.values.brightness) { + return { + brightness: Math.floor(update.values.brightness * 255), + state: update.values.brightness > 0 ? "ON" : "OFF", + }; + } + if (update.values.colorTemperature) { + return { + color_temp: Math.floor(update.values.colorTemperature * 255), + }; + } + } + throw new Error(`${update} is not supported at the moment!`); +}; +export const virtualDeviceUpdateHandler = ( + ha: HAmqtt, + logger: Logger, + haDevice: HADevice, + nodeId: string, + update: VirtualDeviceUpdate, + commandTopic: FlicMqttPrefix, + availability: any, +) => { + const objectId = genVirtualDeviceObjectId(update.metaData); + const mqttPrefix = ha.genFlicPrefixObject(nodeId, objectId); + logger.info(`Handling update for ${update} on ${haDevice}`); + ha.registerEntity( + update.metaData.virtualDeviceId, + VirtualDeviceType2HAComponent[update.metaData.dimmableType], + mqttPrefix.nodeId, + mqttPrefix.objectId, + haDevice, + { availability, command_topic: commandTopic }, + ); + ha.publishState(mqttPrefix.nodeId, mqttPrefix.objectId, { + brightness: update.values.brightness * 255, + }); +}; diff --git a/src/index.ts b/src/index.ts index 30a9fb5..54a64f2 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,77 +1,57 @@ -import {ButtonControllerOpt, makeButtonController} from "./ButtonController"; -import {HAmqttOptions, makeHAmqtt} from './HAmqtt'; -import {IRControllerOpt, makeIRController} from "./IRController"; -import {makeLogger} from "./Logger"; -import {ButtonModule, IRModule} from './flicTypes'; -import * as mqtt from './mqtt'; +import { makeButtonController } from "./button_controller/index"; -export type MQTTOpt = { - host: string; - port: number; - client_id: string; - keep_alive: boolean; - clean_session: boolean; - username: string; - password: string; -} -export type Options = { - mqtt: Partial & { host: string }; - debug?: boolean; - ha?: Partial; - flicBtns?: Partial & { disabled?: boolean }; - flicIR?: Partial & { disabled?: boolean }; -} -export const start = ( - buttonModule: ButtonModule, - irModule: IRModule, - options: Options, -) => { - const mqttServer = mqtt.create( - options.mqtt.host, - {...options.mqtt, keep_alive: true}, - ); - const logger = makeLogger('root', options.debug ?? false); - options.ha = options.ha ?? {}; - options.flicBtns = options.flicBtns ?? {}; - options.flicIR = options.flicIR ?? {}; - options.ha.debug = options.ha.debug ?? options.debug ?? false; - options.flicBtns.debug = options.flicBtns.debug ?? options.debug ?? false; - options.flicIR.debug = options.flicIR.debug ?? options.debug ?? false; - const ha = makeHAmqtt(mqttServer, options.ha); - mqttServer.on('connected', () => { - logger.info("connected to mqtt"); - if (!options.flicBtns?.disabled) { - makeButtonController( - ha, buttonModule, options.flicBtns, - ).start(); - } - if (!options.flicIR?.disabled) { - makeIRController( - irModule, - ha, - mqttServer, - options.flicIR, - ).start(); - } - logger.info("all services up!"); - }); - mqttServer.on('error', function (err) { - logger.info("'Error' event", JSON.stringify(err)); - setTimeout(function () { - throw new Error("Crashed"); - }, 1000); - }); - mqttServer.on("disconnected", function (err) { - logger.info("'Error' disconnected", JSON.stringify(err)); - setTimeout(function () { - throw new Error("Crashed"); - }, 1000); - }); - mqttServer.on("close", function (err) { - logger.info("'Error' close", JSON.stringify(err)); - setTimeout(function () { - throw new Error("Crashed"); - }, 1000); - }); - mqttServer.connect(); -}; \ No newline at end of file +import { makeHAmqtt } from "./ha_mqtt/index"; +import { makeIRController } from "./ir_controller/index"; + +import { makeLogger } from "./Logger"; +import * as mqtt from "./mqtt"; +import { startFlicHubController } from "./hub_controller/index"; + +export const start = (options: Options) => { + const mqttServer = mqtt.create(options.mqtt.host, { + ...options.mqtt, + keep_alive: true, + }); + const logger = makeLogger("root", options.debug ?? false); + options.ha = options.ha ?? {}; + options.flicBtns = options.flicBtns ?? {}; + options.flicIR = options.flicIR ?? {}; + options.flicHub = options.flicHub ?? {}; + options.ha.debug = options.ha.debug ?? options.debug ?? false; + options.flicBtns.debug = options.flicBtns.debug ?? options.debug ?? false; + options.flicIR.debug = options.flicIR.debug ?? options.debug ?? false; + options.flicHub.debug = options.flicHub.debug ?? options.debug ?? false; + const ha = makeHAmqtt(mqttServer, options.ha); + mqttServer.on("connected", () => { + logger.info("connected to mqtt"); + if (!options.flicBtns?.disabled) { + makeButtonController(ha, options.flicBtns).start(); + } + if (!options.flicIR?.disabled) { + makeIRController(ha, mqttServer, options.flicIR).start(); + } + if (!options.flicHub?.disabled) { + startFlicHubController(ha, mqttServer, options.flicHub); + } + logger.info("all services up!"); + }); + mqttServer.on("error", function (err) { + logger.info("'Error' event", JSON.stringify(err)); + setTimeout(function () { + throw new Error("Crashed"); + }, 1000); + }); + mqttServer.on("disconnected", function (err) { + logger.info("'Error' disconnected", JSON.stringify(err)); + setTimeout(function () { + throw new Error("Crashed"); + }, 1000); + }); + mqttServer.on("close", function (err) { + logger.info("'Error' close", JSON.stringify(err)); + setTimeout(function () { + throw new Error("Crashed"); + }, 1000); + }); + mqttServer.connect(); +}; diff --git a/src/ir_controller/index.ts b/src/ir_controller/index.ts new file mode 100644 index 0000000..8946869 --- /dev/null +++ b/src/ir_controller/index.ts @@ -0,0 +1,153 @@ +import ir from "ir"; + +import { HAmqtt } from "../ha_mqtt/index"; +import { makeLogger } from "../Logger"; +import { MQTT } from "../mqtt"; +import { + NODE_ID, + convertStr2Uint32Array, + convertUint32Array2Str, + makeOptions, +} from "./utils"; + +export const makeIRController = ( + ha: HAmqtt, + mqtt: MQTT, + options: Partial = {}, +) => { + options = makeOptions(options); + const logger = makeLogger("ir", options.debug); + const haDevice: HADevice = { + name: "IR", + manufacturer: "Flic", + model: `${NODE_ID}${options.uniqueId}`, + identifiers: ["FlicHubIR"], + configuration_url: "https://hubsdk.flic.io/", + }; + const nodeId = `${NODE_ID}${options.uniqueId}`; + const LIFELINE_SGINAL = ha.genFlicPrefix(nodeId, "lifeline"); + const RECORD_SIGNAL_SET = ha.genFlicPrefix(nodeId, "record/set"); + const VALUE_SIGNAL_SET = ha.genFlicPrefix(nodeId, "signal/set"); + const VALUE_SIGNAL_STATE = ha.genFlicPrefix(nodeId, "signal"); + const PLAY_SIGNAL_SET = ha.genFlicPrefix(nodeId, "play/set"); + const availability = [ + { + payload_available: "ON", + payload_not_available: "unavailable", + topic: LIFELINE_SGINAL, + }, + ]; + let currentSignal: string | null = null; + + const set_topics = [ + RECORD_SIGNAL_SET, + VALUE_SIGNAL_SET, + PLAY_SIGNAL_SET, + VALUE_SIGNAL_STATE, + ]; + + return { + start() { + logger.info("starting..."); + logger.debug("setting up entities..."); + ha.startLifeLine("IR Connnected", nodeId, haDevice); + ha.registerEntity( + "IR Available", + "binary_sensor", + nodeId, + "lifeline", + haDevice, + { + device_class: "connectivity", + expire_after: 5, + off_delay: 3, + entity_category: "diagnostic", + payload_available: "ON", + payload_not_available: "OFF", + }, + ); + ha.registerEntity("Record Signal", "switch", nodeId, "record", haDevice, { + icon: "mdi:record-rec", + command_topic: RECORD_SIGNAL_SET, + device_class: "switch", + availability, + }); + ha.registerEntity("Signal", "text", nodeId, "signal", haDevice, { + command_topic: VALUE_SIGNAL_SET, + icon: "mdi:broadcast", + max: 255, + availability, + }); + ha.registerEntity("Play Signal", "button", nodeId, "play", haDevice, { + icon: "mdi:play", + command_topic: PLAY_SIGNAL_SET, + availability, + }); + logger.debug("setting default states...."); + ha.publishState(nodeId, "record", "OFF"); + ha.publishState(nodeId, "play", "OFF"); + logger.debug("registering events"); + mqtt.on("message", (topic, message) => { + logger.debug("message:", JSON.stringify({ topic, message })); + if (topic === RECORD_SIGNAL_SET) { + logger.debug("starting record"); + ir.record(); + ha.publishState(nodeId, "record", "ON"); + } else if (topic === PLAY_SIGNAL_SET) { + if (currentSignal !== null) { + logger.info("playing", currentSignal); + let arr: Uint32Array | null = null; + try { + arr = convertStr2Uint32Array(currentSignal); + } catch (err) { + logger.error( + "invalid string signal set", + JSON.stringify(err), + err, + ); + return; + } + ir.play(arr, (err) => { + if (err) { + logger.error("failed to play signal", JSON.stringify(err), err); + } else { + logger.debug("signal played!"); + } + }); + } else { + logger.error("cannot play an unset signal"); + } + } else if (topic === VALUE_SIGNAL_STATE) { + currentSignal = message; + logger.info("setting currentSignal", currentSignal); + } else if (topic === VALUE_SIGNAL_SET) { + ha.publishState(nodeId, "signal", message, { retain: true }); + } + }); + ir.on("recordComplete", (data) => { + const stringMessage = convertUint32Array2Str(data); + logger.debug( + "recording completed with", + JSON.stringify({ + data, + stringMessage, + rev: convertStr2Uint32Array(stringMessage), + }), + ); + if (stringMessage.length > 255) { + logger.error( + "stringMessage is too big! size=", + stringMessage.length, + "max=255", + ); + } + ha.publishState(nodeId, "signal", stringMessage, { retain: true }); + ha.publishState(nodeId, "record", "OFF"); + }); + + logger.debug("subscribing to", set_topics); + mqtt.subscribe(set_topics); + logger.info("is up"); + }, + }; +}; diff --git a/src/ir_controller/utils.ts b/src/ir_controller/utils.ts new file mode 100644 index 0000000..304690b --- /dev/null +++ b/src/ir_controller/utils.ts @@ -0,0 +1,20 @@ +export const NODE_ID = "FlicHubIR"; +export const convertUint32Array2Str = (arr: Uint32Array): string => { + let outStr = []; + for (let i = 0; i < arr.length; i++) { + outStr.push(arr[i].toString(32)); + } + return outStr.join("_"); +}; +export const convertStr2Uint32Array = (s: string): Uint32Array => { + const a = s.split("_"); + return new Uint32Array(a.slice(0, a.length - 2).map((v) => parseInt(v, 32))); +}; + +export const makeOptions = ( + opt: Partial, +): IRControllerOpt => ({ + debug: false, + uniqueId: "0", + ...opt, +}); diff --git a/src/mqtt.ts b/src/mqtt.ts index 1791dab..807a3d7 100644 --- a/src/mqtt.ts +++ b/src/mqtt.ts @@ -30,33 +30,33 @@ Modified by Flic Shortcut Labs. /** 'private' constants */ var C = { - PROTOCOL_LEVEL: 4, // MQTT protocol level - DEF_PORT: 1883, // MQTT default server port - DEF_KEEP_ALIVE: 60 // Default keep_alive (s) + PROTOCOL_LEVEL: 4, // MQTT protocol level + DEF_PORT: 1883, // MQTT default server port + DEF_KEEP_ALIVE: 60, // Default keep_alive (s) }; /** Control packet types */ var TYPE = { - CONNECT: 1, - CONNACK: 2, - PUBLISH: 3, - PUBACK: 4, - PUBREC: 5, - PUBREL: 6, - PUBCOMP: 7, - SUBSCRIBE: 8, - SUBACK: 9, - UNSUBSCRIBE: 10, - UNSUBACK: 11, - PINGREQ: 12, - PINGRESP: 13, - DISCONNECT: 14 + CONNECT: 1, + CONNACK: 2, + PUBLISH: 3, + PUBACK: 4, + PUBREC: 5, + PUBREL: 6, + PUBCOMP: 7, + SUBSCRIBE: 8, + SUBACK: 9, + UNSUBSCRIBE: 10, + UNSUBACK: 11, + PINGREQ: 12, + PINGRESP: 13, + DISCONNECT: 14, }; var pakId = Math.floor(Math.random() * 65534); Uint8Array.prototype.charCodeAt = function (a, b) { - return this.toString().charCodeAt(a, b); + return this.toString().charCodeAt(a, b); }; /** @@ -64,99 +64,104 @@ Uint8Array.prototype.charCodeAt = function (a, b) { http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc385349256 **/ var RETURN_CODES = { - 0: 'ACCEPTED', - 1: 'UNACCEPTABLE_PROTOCOL_VERSION', - 2: 'IDENTIFIER_REJECTED', - 3: 'SERVER_UNAVAILABLE', - 4: 'BAD_USER_NAME_OR_PASSWORD', - 5: 'NOT_AUTHORIZED' + 0: "ACCEPTED", + 1: "UNACCEPTABLE_PROTOCOL_VERSION", + 2: "IDENTIFIER_REJECTED", + 3: "SERVER_UNAVAILABLE", + 4: "BAD_USER_NAME_OR_PASSWORD", + 5: "NOT_AUTHORIZED", }; /** MQTT constructor */ function MQTT(server, options) { - this.server = server; - options = options || {}; - this.port = options.port || C.DEF_PORT; - this.client_id = options.client_id || mqttUid(); - this.keep_alive = options.keep_alive || C.DEF_KEEP_ALIVE; - this.clean_session = options.clean_session || true; - this.username = options.username; - this.password = options.password; - this.client = false; - this.connected = false; - /* if keep_alive is less than the ping interval we need to use - a shorter ping interval, otherwise we'll just time out! */ - this.ping_interval = - this.keep_alive < this.C.PING_INTERVAL ? (this.keep_alive - 5) : this.C.PING_INTERVAL; - this.protocol_name = options.protocol_name || "MQTT"; - this.protocol_level = (options.protocol_level || C.PROTOCOL_LEVEL); + this.server = server; + options = options || {}; + this.port = options.port || C.DEF_PORT; + this.client_id = options.client_id || mqttUid(); + this.keep_alive = options.keep_alive || C.DEF_KEEP_ALIVE; + this.clean_session = options.clean_session || true; + this.username = options.username; + this.password = options.password; + this.client = false; + this.connected = false; + /* if keep_alive is less than the ping interval we need to use + a shorter ping interval, otherwise we'll just time out! */ + this.ping_interval = + this.keep_alive < this.C.PING_INTERVAL + ? this.keep_alive - 5 + : this.C.PING_INTERVAL; + this.protocol_name = options.protocol_name || "MQTT"; + this.protocol_level = options.protocol_level || C.PROTOCOL_LEVEL; - if (typeof this.client_id == 'string') { - var payloadarray = [this.client_id.length >> 8, this.client_id.length & 255]; - var i = 2; - var messagearray = this.client_id.split(''); - for (var j = 0; j < this.client_id.length; j++) { - var char = messagearray[j]; - var numberrepres = char.charCodeAt(0); - payloadarray[i] = numberrepres; - i = i + 1; - } - this.client_id = payloadarray; + if (typeof this.client_id == "string") { + var payloadarray = [ + this.client_id.length >> 8, + this.client_id.length & 255, + ]; + var i = 2; + var messagearray = this.client_id.split(""); + for (var j = 0; j < this.client_id.length; j++) { + var char = messagearray[j]; + var numberrepres = char.charCodeAt(0); + payloadarray[i] = numberrepres; + i = i + 1; } - if (this.password) { - var payloadarray = [this.password.length >> 8, this.password.length & 255]; - var i = 2; - var messagearray = this.password.split(''); - for (var j = 0; j < this.password.length; j++) { - var char = messagearray[j]; - var numberrepres = char.charCodeAt(0); - payloadarray[i] = numberrepres; - i = i + 1; - } - this.password = payloadarray; + this.client_id = payloadarray; + } + if (this.password) { + var payloadarray = [this.password.length >> 8, this.password.length & 255]; + var i = 2; + var messagearray = this.password.split(""); + for (var j = 0; j < this.password.length; j++) { + var char = messagearray[j]; + var numberrepres = char.charCodeAt(0); + payloadarray[i] = numberrepres; + i = i + 1; } - if (this.username) { - var payloadarray = [this.username.length >> 8, this.username.length & 255]; - var i = 2; - var messagearray = this.username.split(''); - for (var j = 0; j < this.username.length; j++) { - var char = messagearray[j]; - var numberrepres = char.charCodeAt(0); - payloadarray[i] = numberrepres; - i = i + 1; - } - this.username = payloadarray; + this.password = payloadarray; + } + if (this.username) { + var payloadarray = [this.username.length >> 8, this.username.length & 255]; + var i = 2; + var messagearray = this.username.split(""); + for (var j = 0; j < this.username.length; j++) { + var char = messagearray[j]; + var numberrepres = char.charCodeAt(0); + payloadarray[i] = numberrepres; + i = i + 1; } + this.username = payloadarray; + } } var __listeners = {}; Object.prototype.on = function (type, fn) { - if (!__listeners[type]) { - __listeners[type] = []; - } - __listeners[type].push(fn); + if (!__listeners[type]) { + __listeners[type] = []; + } + __listeners[type].push(fn); }; Object.prototype.emit = function (type, ...data) { - if (__listeners[type]) { - __listeners[type].map(function (fn) { - fn(...data); - }); - } + if (__listeners[type]) { + __listeners[type].map(function (fn) { + fn(...data); + }); + } }; if (!Buffer.from) { - Buffer.from = function (a) { - return new Buffer(a); - }; + Buffer.from = function (a) { + return new Buffer(a); + }; } /** 'public' constants here */ MQTT.prototype.C = { - DEF_QOS: 0, // Default QOS level - CONNECT_TIMEOUT: 10000, // Time (ms) to wait for CONNACK - PING_INTERVAL: 40 // Server ping interval (s) + DEF_QOS: 0, // Default QOS level + CONNECT_TIMEOUT: 10000, // Time (ms) to wait for CONNACK + PING_INTERVAL: 40, // Server ping interval (s) }; /* Utility functions ***************************/ @@ -165,391 +170,419 @@ var fromCharCode = String.fromCharCode; /** MQTT string (length MSB, LSB + data) */ export function mqttStr(s) { - var payloadarray = [s.length >> 8, s.length & 255]; - var i = 2; - var messagearray = s.split(''); - for (var j = 0; j < s.length; j++) { - var char = messagearray[j]; - var numberrepres = char.charCodeAt(0); - payloadarray[i] = numberrepres; - i = i + 1; - } + var payloadarray = [s.length >> 8, s.length & 255]; + var i = 2; + var messagearray = s.split(""); + for (var j = 0; j < s.length; j++) { + var char = messagearray[j]; + var numberrepres = char.charCodeAt(0); + payloadarray[i] = numberrepres; + i = i + 1; + } - return payloadarray; + return payloadarray; } export function mqttInt2Str(arr: number[] | Uint8Array): string { - let outStr = ""; - for (var i = 0; i < arr.length; i++) { - outStr += createEscapedHex(arr[i]); - } - return outStr; + let outStr = ""; + for (var i = 0; i < arr.length; i++) { + outStr += createEscapedHex(arr[i]); + } + return outStr; } /** MQTT packet length formatter - algorithm from reference docs */ function mqttPacketLength(length) { - var encLength = []; - var i = 0; - do { - var encByte = length & 127; - length = length >> 7; - // if there are more data to encode, set the top bit of this byte - if (length > 0) { - encByte += 128; - } - encLength[i] = encByte; - i++; - } while (length > 0); - return encLength; + var encLength = []; + var i = 0; + do { + var encByte = length & 127; + length = length >> 7; + // if there are more data to encode, set the top bit of this byte + if (length > 0) { + encByte += 128; + } + encLength[i] = encByte; + i++; + } while (length > 0); + return encLength; } /** MQTT packet length decoder - algorithm from reference docs */ function mqttPacketLengthDec(length) { - var bytes = 0; - var decL = 0; - var lb = 0; - do { - lb = length[bytes]; - decL |= (lb & 127) << (bytes++ * 7); - } while ((lb & 128) && (bytes < 4)); - return {"decLen": decL, "lenBy": bytes}; + var bytes = 0; + var decL = 0; + var lb = 0; + do { + lb = length[bytes]; + decL |= (lb & 127) << (bytes++ * 7); + } while (lb & 128 && bytes < 4); + return { decLen: decL, lenBy: bytes }; } /** MQTT standard packet formatter */ function mqttPacket(cmd, variable, payload) { - var cmdAndLengthArray = [cmd].concat(mqttPacketLength(variable.length + payload.length)); - var headerAndPayloadArray = cmdAndLengthArray.concat(variable).concat(payload); - var messageBuffer = Buffer.from(headerAndPayloadArray); - return messageBuffer; + var cmdAndLengthArray = [cmd].concat( + mqttPacketLength(variable.length + payload.length), + ); + var headerAndPayloadArray = cmdAndLengthArray + .concat(variable) + .concat(payload); + var messageBuffer = Buffer.from(headerAndPayloadArray); + return messageBuffer; } /** Generate random UID */ var mqttUid = (function () { - function s4() { - var numberstring = Math.floor((1 + Math.random() * 10)); - if (numberstring == 10) numberstring = 9; - numberstring = 97 + numberstring; - return numberstring; - } + function s4() { + var numberstring = Math.floor(1 + Math.random() * 10); + if (numberstring == 10) numberstring = 9; + numberstring = 97 + numberstring; + return numberstring; + } - return function () { - var output = [0, 12, s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4()]; - return output; - }; + return function () { + var output = [ + 0, + 12, + s4(), + s4(), + s4(), + s4(), + s4(), + s4(), + s4(), + s4(), + s4(), + s4(), + s4(), + s4(), + ]; + return output; + }; })(); /** Generate PID */ function mqttPid() { - pakId = pakId > 65534 ? 1 : ++pakId; - return [pakId >> 8, pakId & 0xFF]; + pakId = pakId > 65534 ? 1 : ++pakId; + return [pakId >> 8, pakId & 0xff]; } /** Get PID from message */ function getPid(data) { - return data.slice(0, 2); + return data.slice(0, 2); } /** PUBLISH control packet */ function mqttPublish(topic, message, qos, flags) { - var cmd = TYPE.PUBLISH << 4 | (qos << 1) | flags; - var variable = mqttStr(topic); - // Packet id must be included for QOS > 0 - if (qos > 0) { - var newvariable = variable.concat(mqttPid()); - return mqttPacket(cmd, newvariable, message); - } else { - return mqttPacket(cmd, variable, message); - } + var cmd = (TYPE.PUBLISH << 4) | (qos << 1) | flags; + var variable = mqttStr(topic); + // Packet id must be included for QOS > 0 + if (qos > 0) { + var newvariable = variable.concat(mqttPid()); + return mqttPacket(cmd, newvariable, message); + } else { + return mqttPacket(cmd, variable, message); + } } /** SUBSCRIBE control packet */ function mqttSubscribe(topic, qos) { - var cmd = TYPE.SUBSCRIBE << 4 | 2; - var payloadarray = []; - var i = 0; - var messagearray = topic.split(''); - for (var j = 0; j < topic.length; j++) { - var char = messagearray[j]; - var numberrepres = char.charCodeAt(0); - payloadarray[i] = numberrepres; - i = i + 1; - } - return mqttPacket(cmd, - mqttPid(), - mqttStr(topic).concat([qos])); + var cmd = (TYPE.SUBSCRIBE << 4) | 2; + var payloadarray = []; + var i = 0; + var messagearray = topic.split(""); + for (var j = 0; j < topic.length; j++) { + var char = messagearray[j]; + var numberrepres = char.charCodeAt(0); + payloadarray[i] = numberrepres; + i = i + 1; + } + return mqttPacket(cmd, mqttPid(), mqttStr(topic).concat([qos])); } /** UNSUBSCRIBE control packet */ function mqttUnsubscribe(topic) { - var cmd = TYPE.UNSUBSCRIBE << 4 | 2; - return mqttPacket(cmd, - mqttPid(), - mqttStr(topic)); + var cmd = (TYPE.UNSUBSCRIBE << 4) | 2; + return mqttPacket(cmd, mqttPid(), mqttStr(topic)); } /** Create escaped hex value from number */ function createEscapedHex(n: number): string { - return fromCharCode(parseInt(n.toString(16), 16)); + return fromCharCode(parseInt(n.toString(16), 16)); } // Handle a single packet of data MQTT.prototype.packetHandler = function (data) { + // if we had some data left over from last + // time, add it on + if (this.partData && this.partData.length > 0) { + data = Buffer.from( + Array.prototype.slice + .call(this.partData) + .concat(Array.prototype.slice.call(data)), + ); + this.partData = []; + } - // if we had some data left over from last - // time, add it on - if (this.partData && this.partData.length > 0) { - data = Buffer.from(Array.prototype.slice.call(this.partData).concat(Array.prototype.slice.call(data))); - this.partData = []; + // Figure out packet length... + var dLen = mqttPacketLengthDec(data.slice(1, data.length)); + var pLen = dLen.decLen + dLen.lenBy + 1; + // less than one packet? + if (data.length < pLen) { + this.partData = data; + return; + } + // Get the data for this packet + var pData = data.slice(1 + dLen.lenBy, pLen); + + // more than one packet? re-emit it so we handle it later + if (data.length > pLen) { + this.client.emit("data", data.slice(pLen, data.length)); + } + // Now handle this MQTT packet + var cmd = data[0]; + var type = cmd >> 4; + var flag = cmd & 15; + if (type === TYPE.PUBLISH) { + var qos = (cmd & 0x6) >> 1; + var topic_len = (pData[0] << 8) | pData[1]; + var msg_start = 2 + topic_len + (qos ? 2 : 0); + var parsedData = { + topic: pData.slice(2, 2 + topic_len), + message: pData.slice(msg_start, pData.length), + dup: (cmd & 0x8) >> 3, + qos: qos, + pid: qos ? pData.slice(2 + topic_len, 4 + topic_len) : 0, + retain: cmd & 0x1, + }; + if (parsedData.qos) { + this.client.write([ + (parsedData.qos == 1 ? TYPE.PUBACK : TYPE.PUBREC) << 4, + 2, + parsedData.pid, + ]); } - - // Figure out packet length... - var dLen = mqttPacketLengthDec(data.slice(1, data.length)); - var pLen = dLen.decLen + dLen.lenBy + 1; - // less than one packet? - if (data.length < pLen) { - this.partData = data; - return; + this.emit("publish", parsedData); + this.emit( + "message", + mqttInt2Str(parsedData.topic), + mqttInt2Str(parsedData.message), + ); + } else if (type === TYPE.PUBACK) { + this.emit("puback", (data.charCodeAt(2) << 8) | data.charCodeAt(3)); + } else if (type === TYPE.PUBREC) { + var pubrelArray = [(TYPE.PUBREL << 4) | 2, 2]; + var pidArray = Array.prototype.slice.call(getPid(pData)); + var pubrecResponse = pubrelArray.concat(pidArray); + this.client.write(Buffer.from(pubrecResponse)); + } else if (type === TYPE.PUBREL) { + var pubcompArray = [TYPE.PUBCOMP << 4, 2]; + var pidArray = Array.prototype.slice.call(getPid(pData)); + var pubrelResponse = pubcompArray.concat(pidArray); + this.client.write(pubrelResponse); + } else if (type === TYPE.PUBCOMP) { + this.emit("pubcomp", (data.charCodeAt(2) << 8) | data.charCodeAt(3)); + } else if (type === TYPE.SUBACK) { + if (pData.length > 0) { + if (pData[pData.length - 1] == 0x80) { + this.emit("subscribed_fail"); + } else { + this.emit("subscribed"); + } } - - // Allow zero-size pData, but detect if its indexes - // will go out of bounds. - if (1 + dLen.lenBy >= data.length) { - return; - } - - // Get the data for this packet - var pData = data.slice(1 + dLen.lenBy, pLen); - - // more than one packet? re-emit it so we handle it later - if (data.length > pLen) { - this.client.emit('data', data.slice(pLen, data.length)); - } - // Now handle this MQTT packet - var cmd = data[0]; - var type = cmd >> 4; - var flag = cmd & 15; - if (type === TYPE.PUBLISH) { - var qos = (cmd & 0x6) >> 1; - var topic_len = pData[0] << 8 | pData[1]; - var msg_start = 2 + topic_len + (qos ? 2 : 0); - var parsedData = { - topic: pData.slice(2, 2 + topic_len), - message: pData.slice(msg_start, pData.length), - dup: (cmd & 0x8) >> 3, - qos: qos, - pid: qos ? pData.slice(2 + topic_len, 4 + topic_len) : 0, - retain: cmd & 0x1 - }; - if (parsedData.qos) { - this.client.write([((parsedData.qos == 1) ? TYPE.PUBACK : TYPE.PUBREC) << 4, 2, parsedData.pid]); - } - this.emit('publish', parsedData); - this.emit('message', mqttInt2Str(parsedData.topic), mqttInt2Str(parsedData.message)); - } else if (type === TYPE.PUBACK) { - this.emit('puback', data.charCodeAt(2) << 8 | data.charCodeAt(3)); - } else if (type === TYPE.PUBREC) { - var pubrelArray = [(TYPE.PUBREL << 4 | 2), 2]; - var pidArray = Array.prototype.slice.call(getPid(pData)); - var pubrecResponse = pubrelArray.concat(pidArray); - this.client.write(Buffer.from(pubrecResponse)); - } else if (type === TYPE.PUBREL) { - var pubcompArray = [(TYPE.PUBCOMP << 4), 2]; - var pidArray = Array.prototype.slice.call(getPid(pData)); - var pubrelResponse = pubcompArray.concat(pidArray); - this.client.write(pubrelResponse); - } else if (type === TYPE.PUBCOMP) { - this.emit('pubcomp', data.charCodeAt(2) << 8 | data.charCodeAt(3)); - } else if (type === TYPE.SUBACK) { - if (pData.length > 0) { - if (pData[pData.length - 1] == 0x80) { - this.emit('subscribed_fail'); - } else { - this.emit('subscribed'); - } - } - } else if (type === TYPE.UNSUBACK) { - this.emit('unsubscribed'); - } else if (type === TYPE.PINGREQ) { - this.client.write([(TYPE.PINGRESP << 4), 0]); - } else if (type === TYPE.PINGRESP) { - this.emit('ping_reply'); - } else if (type === TYPE.CONNACK) { - if (this.ctimo) clearTimeout(this.ctimo); - this.ctimo = undefined; - this.partData = []; - var returnCode = pData[1]; - if (RETURN_CODES[returnCode] === 'ACCEPTED') { - this.connected = true; - // start pinging - if (this.pintr) clearInterval(this.pintr); - this.pintr = setInterval(this.ping.bind(this), this.ping_interval * 1000); - // emit connected events - this.emit('connected'); - this.emit('connect'); - } else { - var mqttError = "Connection refused, "; - this.connected = false; - if (returnCode > 0 && returnCode < 6) { - mqttError += RETURN_CODES[returnCode]; - } else { - mqttError += "unknown return code: " + returnCode + "."; - } - this.emit('error', mqttError); - } + } else if (type === TYPE.UNSUBACK) { + this.emit("unsubscribed"); + } else if (type === TYPE.PINGREQ) { + this.client.write([TYPE.PINGRESP << 4, 0]); + } else if (type === TYPE.PINGRESP) { + this.emit("ping_reply"); + } else if (type === TYPE.CONNACK) { + if (this.ctimo) clearTimeout(this.ctimo); + this.ctimo = undefined; + this.partData = []; + var returnCode = pData[1]; + if (RETURN_CODES[returnCode] === "ACCEPTED") { + this.connected = true; + // start pinging + if (this.pintr) clearInterval(this.pintr); + this.pintr = setInterval(this.ping.bind(this), this.ping_interval * 1000); + // emit connected events + this.emit("connected"); + this.emit("connect"); } else { - this.emit('error', "MQTT unsupported packet type: " + type); + var mqttError = "Connection refused, "; + this.connected = false; + if (returnCode > 0 && returnCode < 6) { + mqttError += RETURN_CODES[returnCode]; + } else { + mqttError += "unknown return code: " + returnCode + "."; + } + this.emit("error", mqttError); } + } else { + this.emit("error", "MQTT unsupported packet type: " + type); + } }; /* Public interface ****************************/ /** Establish connection and set up keep_alive ping */ MQTT.prototype.connect = function (client) { - if (this.connected) return; - var mqo = this; - var onConnect = function () { - mqo.client = client; - // write connection message - var teststring = mqo.mqttConnect(mqo.client_id); - client.write(teststring); - // handle connection timeout if too slow - mqo.ctimo = setTimeout(function () { - mqo.ctimo = undefined; - mqo.emit('disconnected'); - mqo.disconnect(); - }, mqo.C.CONNECT_TIMEOUT); - // Incoming data - client.on('data', mqo.packetHandler.bind(mqo)); - // Socket closed - client.on('end', function () { - mqo._scktClosed(); - }); - }; - if (client) { - onConnect(); - } else { - try { - var self = this; - client = require("net").Socket().connect({host: mqo.server, port: mqo.port}, onConnect); - client.on('error', function (err) { - self.emit('error', err.message); - }); - } catch (e) { - this.client = false; - this.emit('error', e.message); - } + if (this.connected) return; + var mqo = this; + var onConnect = function () { + mqo.client = client; + // write connection message + var teststring = mqo.mqttConnect(mqo.client_id); + client.write(teststring); + // handle connection timeout if too slow + mqo.ctimo = setTimeout(function () { + mqo.ctimo = undefined; + mqo.emit("disconnected"); + mqo.disconnect(); + }, mqo.C.CONNECT_TIMEOUT); + // Incoming data + client.on("data", mqo.packetHandler.bind(mqo)); + // Socket closed + client.on("end", function () { + mqo._scktClosed(); + }); + }; + if (client) { + onConnect(); + } else { + try { + var self = this; + client = require("net") + .Socket() + .connect({ host: mqo.server, port: mqo.port }, onConnect); + client.on("error", function (err) { + self.emit("error", err.message); + }); + } catch (e) { + this.client = false; + this.emit("error", e.message); } + } }; /** Called internally when the connection closes */ MQTT.prototype._scktClosed = function () { - if (this.connected) { - this.connected = false; - this.client = false; - if (this.pintr) clearInterval(this.pintr); - if (this.ctimo) clearTimeout(this.ctimo); - this.pintr = this.ctimo = undefined; - this.emit('disconnected'); - this.emit('close'); - } + if (this.connected) { + this.connected = false; + this.client = false; + if (this.pintr) clearInterval(this.pintr); + if (this.ctimo) clearTimeout(this.ctimo); + this.pintr = this.ctimo = undefined; + this.emit("disconnected"); + this.emit("close"); + } }; /** Disconnect from server */ MQTT.prototype.disconnect = function () { - if (!this.client) return; - try { - this.client.write(Buffer.from([(TYPE.DISCONNECT << 4), 0])); - } catch (e) { - return this._scktClosed(); - } - this.client.end(); - this.client = false; + if (!this.client) return; + try { + this.client.write(Buffer.from([TYPE.DISCONNECT << 4, 0])); + } catch (e) { + return this._scktClosed(); + } + this.client.end(); + this.client = false; }; /** Publish message using specified topic. - opts = { - retain: bool // the server should retain this message and send it out again to new subscribers - dup : bool // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) - } - */ + opts = { + retain: bool // the server should retain this message and send it out again to new subscribers + dup : bool // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) + } +*/ MQTT.prototype.publish = function (topic, message, opts) { - if (!this.client) return; - opts = opts || {}; - try { - var payloadarray = []; - var i = 0; - var messagearray = message.split(''); - for (var j = 0; j < message.length; j++) { - var char = messagearray[j]; - var numberrepres = char.charCodeAt(0); - payloadarray[i] = numberrepres; - i = i + 1; - } - var publishMessage = mqttPublish(topic, payloadarray, opts.qos || this.C.DEF_QOS, (opts.retain ? 1 : 0) | (opts.dup ? 8 : 0)); - this.client.write(publishMessage); - } catch (e) { - this._scktClosed(); + if (!this.client) return; + opts = opts || {}; + try { + var payloadarray = []; + var i = 0; + var messagearray = message.split(""); + for (var j = 0; j < message.length; j++) { + var char = messagearray[j]; + var numberrepres = char.charCodeAt(0); + payloadarray[i] = numberrepres; + i = i + 1; } + var publishMessage = mqttPublish( + topic, + payloadarray, + opts.qos || this.C.DEF_QOS, + (opts.retain ? 1 : 0) | (opts.dup ? 8 : 0), + ); + this.client.write(publishMessage); + } catch (e) { + this._scktClosed(); + } }; /** Subscribe to topic (filter) */ MQTT.prototype.subscribe = function (topics, opts) { - if (!this.client) return; - opts = opts || {}; + if (!this.client) return; + opts = opts || {}; - var subs = []; - if ('string' === typeof topics) { - topics = [topics]; - } - if (Array.isArray(topics)) { - topics.forEach(function (topic) { - subs.push({ - topic: topic, - qos: opts.qos || this.C.DEF_QOS - }); - }.bind(this)); - } else { - Object - .keys(topics) - .forEach(function (k) { - subs.push({ - topic: k, - qos: topics[k] - }); - }); - } + var subs = []; + if ("string" === typeof topics) { + topics = [topics]; + } + if (Array.isArray(topics)) { + topics.forEach( + function (topic) { + subs.push({ + topic: topic, + qos: opts.qos || this.C.DEF_QOS, + }); + }.bind(this), + ); + } else { + Object.keys(topics).forEach(function (k) { + subs.push({ + topic: k, + qos: topics[k], + }); + }); + } - subs.forEach(function (sub) { - var subpacket = mqttSubscribe(sub.topic, sub.qos); - this.client.write(subpacket); - }.bind(this)); + subs.forEach( + function (sub) { + var subpacket = mqttSubscribe(sub.topic, sub.qos); + this.client.write(subpacket); + }.bind(this), + ); }; /** Unsubscribe to topic (filter) */ MQTT.prototype.unsubscribe = function (topic) { - if (!this.client) return; - this.client.write(mqttUnsubscribe(topic)); + if (!this.client) return; + this.client.write(mqttUnsubscribe(topic)); }; /** Send ping request to server */ MQTT.prototype.ping = function () { - if (!this.client) return; - try { - this.client.write(Buffer.from([TYPE.PINGREQ << 4, 0])); - } catch (e) { - this._scktClosed(); - } + if (!this.client) return; + try { + this.client.write(Buffer.from([TYPE.PINGREQ << 4, 0])); + } catch (e) { + this._scktClosed(); + } }; /* Packet specific functions *******************/ /** Create connection flags */ MQTT.prototype.createFlagsForConnection = function (options) { - var flags = 0; - flags |= (this.username) ? 0x80 : 0; - flags |= (this.username && this.password) ? 0x40 : 0; - flags |= (options.clean_session) ? 0x02 : 0; - return flags; + var flags = 0; + flags |= this.username ? 0x80 : 0; + flags |= this.username && this.password ? 0x40 : 0; + flags |= options.clean_session ? 0x02 : 0; + return flags; }; /** CONNECT control packet @@ -558,77 +591,72 @@ MQTT.prototype.createFlagsForConnection = function (options) { currently supported. */ MQTT.prototype.mqttConnect = function (clean) { - var cmd = TYPE.CONNECT << 4; - var flags = this.createFlagsForConnection({ - clean_session: clean - }); + var cmd = TYPE.CONNECT << 4; + var flags = this.createFlagsForConnection({ + clean_session: clean, + }); - var keep_alive = [this.keep_alive >> 8, this.keep_alive & 255]; + var keep_alive = [this.keep_alive >> 8, this.keep_alive & 255]; - /* payload */ - var payload = this.client_id; - if (this.username) { - payload = payload.concat(this.username); - if (this.password) { - payload = payload.concat(this.password); - } + /* payload */ + var payload = this.client_id; + if (this.username) { + payload = payload.concat(this.username); + if (this.password) { + payload = payload.concat(this.password); } - return mqttPacket(cmd, - mqttStr(this.protocol_name)/*protocol name*/.concat( - [this.protocol_level]) /*protocol level*/.concat( - [flags]).concat(keep_alive), - payload); + } + return mqttPacket( + cmd, + mqttStr(this.protocol_name) /*protocol name*/ + .concat([this.protocol_level]) /*protocol level*/ + .concat([flags]) + .concat(keep_alive), + payload, + ); }; /* Exports *************************************/ /** This is 'exported' so it can be used with `require('MQTT.js').create(server, options)` */ export function create(server, options): MQTT { - return new MQTT(server, options); + return new MQTT(server, options); } export function connect(options): MQTT { - var mqtt = new MQTT(options.host, options); - mqtt.connect(); - return mqtt; + var mqtt = new MQTT(options.host, options); + mqtt.connect(); + return mqtt; } - export interface MQTT { - connect(): void; - - publish(topic: string, message: string, opts: { - retain?: boolean, // the server should retain this message and send it out again to new subscribers - dup?: boolean, // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) - } | undefined): void; - - subscribe(topics: string[]): void; - - unsubscribe(topic: string): void; - - on(ev: 'publish', cb: (data: { topic: Buffer, message: Buffer }) => void): void; - - on(ev: 'message', cb: (topic: string, message: string) => void): void; - - on(ev: 'puback', cb: (data) => void): void; - - on(ev: 'pubcomp', cb: (data) => void): void; - - on(ev: 'subscribed_fail', cb: (data) => void): void; - - on(ev: 'subscribed', cb: (data) => void): void; - - on(ev: 'unsubscribed', cb: (data) => void): void; - - on(ev: 'ping_reply', cb: (data) => void): void; - - on(ev: 'connected', cb: (data) => void): void; - - on(ev: 'connect', cb: (data) => void): void; - - on(ev: 'error', cb: (data) => void): void; - - on(ev: 'disconnected', cb: (data) => void): void; - - on(ev: 'close', cb: (data) => void): void; + connect(): void; + publish( + topic: string, + message: string, + opts: + | { + retain?: boolean; // the server should retain this message and send it out again to new subscribers + dup?: boolean; // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) + } + | undefined, + ): void; + subscribe(topics: string[]): void; + unsubscribe(topic: string): void; + on( + ev: "publish", + cb: (data: { topic: Buffer; message: Buffer }) => void, + ): void; + on(ev: "message", cb: (topic: string, message: string) => void): void; + on(ev: "puback", cb: (data) => void): void; + on(ev: "pubcomp", cb: (data) => void): void; + on(ev: "subscribed_fail", cb: (data) => void): void; + on(ev: "subscribed", cb: (data) => void): void; + on(ev: "unsubscribed", cb: (data) => void): void; + on(ev: "ping_reply", cb: (data) => void): void; + on(ev: "connected", cb: (data) => void): void; + on(ev: "connect", cb: (data) => void): void; + on(ev: "error", cb: (data) => void): void; + on(ev: "disconnected", cb: (data) => void): void; + on(ev: "close", cb: (data) => void): void; } diff --git a/tsconfig.json b/tsconfig.json index 41be1a3..21ebd16 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -1,10 +1,7 @@ { - "compilerOptions": { - "target": "ES2015", - "module": "ESNext" - }, - "include": [ - "src/**/*", - "rollup.config.ts" - ], -} \ No newline at end of file + "compilerOptions": { + "target": "ES2015", + "module": "ESNext" + }, + "include": ["src/**/*", "rollup.config.ts", "types/*"] +} diff --git a/types/flic.sdk.buttons.d.ts b/types/flic.sdk.buttons.d.ts new file mode 100644 index 0000000..3f26a64 --- /dev/null +++ b/types/flic.sdk.buttons.d.ts @@ -0,0 +1,118 @@ +/** + * Flic Hub Studio - Buttons Module + * TypeScript Declaration File + */ + +declare module "buttons" { + import { EventEmitter } from "events"; + + /** Button Object Type */ + export interface Button { + bdaddr: string; + serialNumber: string; + color: string; + name: string; + activeDisconnect: boolean; + connected: boolean; + ready: boolean; + batteryStatus: number | null; + firmwareVersion: number | null; + flicVersion: 1 | 2; + uuid: string; + key?: string; // Only for Flic 2 + } + + /** ScanWizard Event Types */ + type ScanWizardEventMap = { + foundPrivateButton: []; + foundPublicButton: [{ bdaddr: string }]; + buttonConnect: [{ bdaddr: string }]; + complete: [{ bdaddr: string }]; + fail: [{ error: ScanWizardFailReason }]; + }; + + export type ScanWizardFailReason = + | "CancelledByUser" + | "FailedTimeout" + | "ButtonIsPrivate" + | "BluetoothUnavailable" + | "InternetBackendError" + | "InvalidData"; + + /** ScanWizard Class */ + export interface ScanWizard extends EventEmitter { + on( + event: K, + listener: (...args: ScanWizardEventMap[K]) => void, + ): this; + once( + event: K, + listener: (...args: ScanWizardEventMap[K]) => void, + ): this; + emit( + event: K, + ...args: ScanWizardEventMap[K] + ): boolean; + + cancel(): void; + } + + /** Buttons Event Types */ + export type ButtonsEventMap = { + buttonAdded: [{ button: Button }]; + buttonUpdated: [{ button: Button }]; + buttonDeleted: [{ bdaddr: string }]; + buttonConnected: [{ bdaddr: string }]; + buttonReady: [{ bdaddr: string }]; + buttonDisconnected: [{ bdaddr: string }]; + buttonDown: [{ bdaddr: string }]; + buttonUp: [{ bdaddr: string }]; + buttonClickOrHold: [{ bdaddr: string; isClick: boolean; isHold: boolean }]; + buttonSingleOrDoubleClick: [ + { bdaddr: string; isSingleClick: boolean; isDoubleClick: boolean }, + ]; + buttonSingleOrDoubleClickOrHold: [ + { + bdaddr: string; + isSingleClick: boolean; + isDoubleClick: boolean; + isHold: boolean; + }, + ]; + }; + + /** Buttons Class */ + export interface Buttons extends EventEmitter { + on( + event: K, + listener: (...args: ButtonsEventMap[K]) => void, + ): this; + once( + event: K, + listener: (...args: ButtonsEventMap[K]) => void, + ): this; + emit( + event: K, + ...args: ButtonsEventMap[K] + ): boolean; + + getButtons(): Button[]; + getButton(bdaddr: string): Button | null; + startScanWizard(): ScanWizard; + + importFlic2Pairings( + pairings: Array<{ + bdaddr: string; + serialNumber: string; + color: string; + firmwareVersion: number; + uuid: string; + key: string; + }>, + callback: () => void, + ): void; + } + + const buttons: Buttons; + export default buttons; +} diff --git a/types/flic.sdk.flicapp.d.ts b/types/flic.sdk.flicapp.d.ts new file mode 100644 index 0000000..79f49e2 --- /dev/null +++ b/types/flic.sdk.flicapp.d.ts @@ -0,0 +1,84 @@ +declare module "flicapp" { + import { EventEmitter } from "events"; + /** + * The FlicApp class allows integration with virtual devices and message actions + * configured in the Flic mobile app for use with Flic Twist and other controls. + */ + export class FlicApp extends EventEmitter { + /** + * Emitted when a message action configured in the Flic app is triggered. + * Useful for advanced Flic Twist configurations like action points in dimming or Scene Blender. + * + * @event actionMessage + * @param message - The configured message string from the Flic app + */ + on(event: "actionMessage", listener: (message: string) => void): this; + + /** + * Emitted when a Flic Twist rotation updates a virtual device. + * Only includes the fields that changed in this update. + * + * @event virtualDeviceUpdate + * @param update - Object containing metadata and updated values + */ + on( + event: "virtualDeviceUpdate", + listener: (update: VirtualDeviceUpdate) => void, + ): this; + + /** + * Updates the state of a virtual device in the Flic app to reflect external changes. + * This keeps the Flic Twist in sync (e.g., LED indicators, small movements). + * + * Note: For Advanced Dimming and Scene Blender, this is not required as communication is one-way. + * + * @param type - Type of the virtual device + * @param id - Identifier of the virtual device (must match Flic app configuration) + * @param values - Partial state update with values between 0 and 1 + */ + virtualDeviceUpdateState( + type: VirtualDeviceType, + id: string, + values: VirtualDeviceValues, + ): void; + } + + /** Supported virtual device types */ + export type VirtualDeviceType = "Light" | "Blind" | "Speaker"; + + /** Metadata included in virtualDeviceUpdate events */ + export interface VirtualDeviceMetaData { + /** ID of the Flic Button or Twist that triggered the change */ + buttonId: string; + /** Type of dimmable device */ + dimmableType: VirtualDeviceType; + /** ID of the virtual device being controlled */ + virtualDeviceId: string; + } + + /** Possible value fields in virtual device updates */ + export interface VirtualDeviceValues { + /** Brightness level (0 to 1) - for Light, Blind, Speaker */ + brightness?: number; + /** Hue (0 to 1) - for Light */ + hue?: number; + /** Saturation (0 to 1) - for Light */ + saturation?: number; + /** Color temperature (0 to 1) - for Light */ + colorTemperature?: number; + /** Volume level (0 to 1) - for Speaker */ + volume?: number; + /** Position (0 to 1) - for Blind */ + position?: number; + } + + /** Full structure of a virtualDeviceUpdate event */ + export interface VirtualDeviceUpdate { + metaData: VirtualDeviceMetaData; + values: VirtualDeviceValues; + } + + /** The exported module instance */ + const flicapp: FlicApp; + export default flicapp; +} diff --git a/types/flic.sdk.hubinfo.d.ts b/types/flic.sdk.hubinfo.d.ts new file mode 100644 index 0000000..15745d8 --- /dev/null +++ b/types/flic.sdk.hubinfo.d.ts @@ -0,0 +1,8 @@ +declare module "hubinfo" { + export interface HubInfo { + serialNumber: string; + firmwareVersion: string; + } + const hubinfo: HubInfo; + export default hubinfo; +} diff --git a/types/flic.sdk.irmodule.d.ts b/types/flic.sdk.irmodule.d.ts new file mode 100644 index 0000000..614bdff --- /dev/null +++ b/types/flic.sdk.irmodule.d.ts @@ -0,0 +1,22 @@ +/** + * Flic Hub Studio - IR Module + * TypeScript Declaration File + */ + +declare module "ir" { + import { EventEmitter } from "events"; + + /** IR Class */ + export interface IR extends EventEmitter { + on(event: "recordComplete", listener: (arr: Uint32Array) => void): this; + once(event: "recordComplete", listener: (arr: Uint32Array) => void): this; + emit(event: "recordComplete", arr: Uint32Array): boolean; + + record(): void; + cancelRecord(): void; + play(arr: Uint32Array, callback: (error: any) => void): void; + } + + const ir: IR; + export default ir; +} diff --git a/types/ha.types.d.ts b/types/ha.types.d.ts new file mode 100644 index 0000000..3befdb5 --- /dev/null +++ b/types/ha.types.d.ts @@ -0,0 +1,25 @@ +type HADevice = { + name: string; + identifiers: string[]; + manufacturer: string; + model: string; + sw_version?: string; + hw_version?: string; + serial_number?: string; + configuration_url?: string; +}; +type HAComponent = + | "cover" + | "media_player" + | "light" + | "sensor" + | "binary_sensor" + | "button" + | "switch" + | "text" + | "device_automation"; +type FlicMqttPrefix = { + nodeId: string; + objectId: string; + mqttPrefix: string; +}; diff --git a/types/options.types.d.ts b/types/options.types.d.ts new file mode 100644 index 0000000..09d93c3 --- /dev/null +++ b/types/options.types.d.ts @@ -0,0 +1,39 @@ +type HAmqttOptions = { + debug: boolean; + topics: { + homeassistant: string; + flic: string; + }; +}; +type MQTTPublishOpt = { + retain?: boolean; // the server should retain this message and send it out again to new subscribers + dup?: boolean; // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only) +}; +type ButtonControllerOpt = { + debug: boolean; +}; +type IRControllerOpt = { + uniqueId: string; + debug: boolean; +}; +type FlicHubOptions = { + uniqueId: string; + debug: boolean; +}; +type MQTTOpt = { + host: string; + port: number; + client_id: string; + keep_alive: boolean; + clean_session: boolean; + username: string; + password: string; +}; +type Options = { + mqtt: Partial & { host: string }; + debug?: boolean; + ha?: Partial; + flicBtns?: Partial & { disabled?: boolean }; + flicIR?: Partial & { disabled?: boolean }; + flicHub?: Partial & { disabled?: boolean }; +};