cspot fixes - release

CHANGELOG

@@ -1,3 +1,8 @@
+2023-10-06
+ - fix cspot PREV on first track, NEXT on last track and normal ending
+ - use DMA_AUTO for SPI
+ - cspot share same time log
+ 
 2023-10-06
  - Fix bootswatch bug that caused difficult to read UI ( issue #319)
 

components/platform_console/cmd_i2ctools.c

@@ -477,7 +477,7 @@ static int do_spiconfig_cmd(int argc, char **argv){
 
 	if(!nerrors){
 		fprintf(f,"Configuring SPI data=%d clock=%d host=%u dc: %d\n", spi_config.mosi_io_num, spi_config.sclk_io_num, host, dc);
-		err=spi_bus_initialize( host, &spi_config, 1 );
+		err=spi_bus_initialize( host, &spi_config, SPI_DMA_CH_AUTO );
 		if(err!=ESP_OK){
 			if(err==ESP_ERR_INVALID_STATE){
 				// if user is changing the host number, we need to try freeing both hosts
@@ -485,7 +485,7 @@ static int do_spiconfig_cmd(int argc, char **argv){
 					fprintf(f,"SPI bus init failed. Please clear SPI configuration, restart the device and try again. %s\n", esp_err_to_name(err));
 					nerrors++;
 				}
-				else if((err=spi_bus_initialize( host, &spi_config, 1 ))!=ESP_OK){
+				else if((err=spi_bus_initialize( host, &spi_config, SPI_DMA_CH_AUTO ))!=ESP_OK){
 					fprintf(f,"Failed to initialize SPI Bus. %s\n", esp_err_to_name(err));
 					nerrors++;
 				}

components/services/services.c

@@ -380,7 +380,7 @@ void services_init(void) {
 	ESP_LOGI(TAG,"Configuring SPI mosi:%d miso:%d clk:%d host:%u dc:%d", spi_config->mosi_io_num, spi_config->miso_io_num, spi_config->sclk_io_num, spi_system_host, spi_system_dc_gpio);
 
 	if (spi_config->mosi_io_num != -1 && spi_config->sclk_io_num != -1) {
-		spi_bus_initialize( spi_system_host, spi_config, 1 );
+		spi_bus_initialize( spi_system_host, spi_config, SPI_DMA_CH_AUTO );
 		if (spi_system_dc_gpio != -1) {
 			gpio_reset_pin(spi_system_dc_gpio);
 			gpio_set_direction( spi_system_dc_gpio, GPIO_MODE_OUTPUT );

components/spotify/Shim.cpp

@@ -229,7 +229,6 @@ void cspotPlayer::eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event
     case cspot::SpircHandler::EventType::NEXT:
     case cspot::SpircHandler::EventType::PREV:
     case cspot::SpircHandler::EventType::FLUSH: {
-        // FLUSH is sent when there is no next, just clean everything
         cmdHandler(CSPOT_FLUSH);
         break;
     }
@@ -424,7 +423,7 @@ void cspotPlayer::runTask() {
                         CSPOT_LOG(info, "last track finished");
                         trackStatus = TRACK_INIT;
                         cmdHandler(CSPOT_STOP);
-                        spirc->setPause(true);
+                        spirc->notifyAudioEnded();
                     }
                 }
                 
@@ -461,6 +460,7 @@ void cspotPlayer::runTask() {
  */
 struct cspot_s* cspot_create(const char *name, httpd_handle_t server, int port, cspot_cmd_cb_t cmd_cb, cspot_data_cb_t data_cb) {
 	bell::setDefaultLogger();
+    bell::enableTimestampLogging(true);
     player = new cspotPlayer(name, server, port, cmd_cb, data_cb);
     player->startTask();
 	return (cspot_s*) player;

components/spotify/cspot/bell/main/utilities/BellLogger.cpp

@@ -10,6 +10,7 @@ void bell::enableSubmoduleLogging() {
   bell::bellGlobalLogger->enableSubmodule = true;
 }
 
-void bell::enableTimestampLogging() {
+void bell::enableTimestampLogging(bool local) {
   bell::bellGlobalLogger->enableTimestamp = true;
+  bell::bellGlobalLogger->shortTime = local;
 }

components/spotify/cspot/bell/main/utilities/include/BellLogger.h

@@ -14,6 +14,7 @@ class AbstractLogger {
  public:
   bool enableSubmodule = false;
   bool enableTimestamp = false;
+  bool shortTime = false;
 
   virtual void debug(std::string filename, int line, std::string submodule,
                      const char* format, ...) = 0;
@@ -94,10 +95,18 @@ class BellLogger : public bell::AbstractLogger {
                              now.time_since_epoch()) %
                          1000;
 
-      auto gmt_time = gmtime(&now_time);
       printf(colorReset);
-      std::cout << std::put_time(gmt_time, "[%Y-%m-%d %H:%M:%S") << '.'
-                << std::setfill('0') << std::setw(3) << nowMs.count() << "] ";
+      struct tm* gmt_time;
+      if (shortTime) {
+        gmt_time = localtime(&now_time);
+        std::cout << std::put_time(gmt_time, "[%H:%M:%S") << '.'
+                  << std::setfill('0') << std::setw(3) << nowMs.count() << "] ";
+      }
+      else {
+          gmt_time = gmtime(&now_time);
+          std::cout << std::put_time(gmt_time, "[%Y-%m-%d %H:%M:%S") << '.'
+              << std::setfill('0') << std::setw(3) << nowMs.count() << "] ";
+      }
     }
   }
 
@@ -129,7 +138,7 @@ class BellLogger : public bell::AbstractLogger {
 
 void setDefaultLogger();
 void enableSubmoduleLogging();
-void enableTimestampLogging();
+void enableTimestampLogging(bool local = false);
 }  // namespace bell
 
 #define BELL_LOG(type, ...)                                        \

components/spotify/cspot/include/SpircHandler.h

@@ -48,11 +48,12 @@ class SpircHandler {
 
   void setPause(bool pause);
 
-  void previousSong();
+  bool previousSong();
 
-  void nextSong();
+  bool nextSong();
 
   void notifyAudioReachedPlayback();
+  void notifyAudioEnded();
   void updatePositionMs(uint32_t position);
   void setRemoteVolume(int volume);
   void loadTrackFromURI(const std::string& uri);
@@ -74,7 +75,7 @@ class SpircHandler {
   void sendEvent(EventType type);
   void sendEvent(EventType type, EventData data);
 
-  void skipSong(TrackQueue::SkipDirection dir);
+  bool skipSong(TrackQueue::SkipDirection dir);
   void handleFrame(std::vector<uint8_t>& data);
   void notify();
 };

components/spotify/cspot/include/TrackPlayer.h

@@ -32,7 +32,7 @@ struct TrackReference;
 class TrackPlayer : bell::Task {
  public:
   // Callback types
-  typedef std::function<void(std::shared_ptr<QueuedTrack>)> TrackLoadedCallback;
+  typedef std::function<void(std::shared_ptr<QueuedTrack>, bool)> TrackLoadedCallback;
   typedef std::function<size_t(uint8_t*, size_t, std::string_view)>
       DataCallback;
   typedef std::function<void()> EOFCallback;
@@ -49,7 +49,7 @@ class TrackPlayer : bell::Task {
 
   // CDNTrackStream::TrackInfo getCurrentTrackInfo();
   void seekMs(size_t ms);
-  void resetState();
+  void resetState(bool paused = false);
 
   // Vorbis codec callbacks
   size_t _vorbisRead(void* ptr, size_t size, size_t nmemb);
@@ -89,6 +89,7 @@ class TrackPlayer : bell::Task {
   std::atomic<bool> pendingReset = false;
   std::atomic<bool> inFuture = false;
   std::atomic<size_t> pendingSeekPositionMs = 0;
+  std::atomic<bool> startPaused = false;
 
   std::mutex runningMutex;
 

components/spotify/cspot/src/SpircHandler.cpp

@@ -31,15 +31,15 @@ SpircHandler::SpircHandler(std::shared_ptr<cspot::Context> ctx) {
     }
   };
 
-  auto trackLoadedCallback = [this](std::shared_ptr<QueuedTrack> track) {
-    playbackState->setPlaybackState(PlaybackState::State::Playing);
+  auto trackLoadedCallback = [this](std::shared_ptr<QueuedTrack> track, bool paused = false) {
+    playbackState->setPlaybackState(paused ? PlaybackState::State::Paused : PlaybackState::State::Playing);
     playbackState->updatePositionMs(track->requestedPosition);
 
     this->notify();
 
-    // Send playback start event, unpause
+    // Send playback start event, pause/unpause per request
     sendEvent(EventType::PLAYBACK_START, (int)track->requestedPosition);
-    sendEvent(EventType::PLAY_PAUSE, false);
+    sendEvent(EventType::PLAY_PAUSE, paused);
   };
 
   this->ctx = ctx;
@@ -77,6 +77,12 @@ void SpircHandler::subscribeToMercury() {
 
 void SpircHandler::loadTrackFromURI(const std::string& uri) {}
 
+void SpircHandler::notifyAudioEnded() {
+    playbackState->updatePositionMs(0);
+    notify();
+    trackPlayer->resetState(true);
+}
+
 void SpircHandler::notifyAudioReachedPlayback() {
   int offset = 0;
 
@@ -142,7 +148,6 @@ void SpircHandler::handleFrame(std::vector<uint8_t>& data) {
       notify();
 
       sendEvent(EventType::SEEK, (int)playbackState->remoteFrame.position);
-      //sendEvent(EventType::FLUSH);
       break;
     }
     case MessageType_kMessageTypeVolume:
@@ -157,12 +162,14 @@ void SpircHandler::handleFrame(std::vector<uint8_t>& data) {
       setPause(false);
       break;
     case MessageType_kMessageTypeNext:
-      nextSong();
-      sendEvent(EventType::NEXT);
+      if (nextSong()) {
+        sendEvent(EventType::NEXT);
+      }
       break;
     case MessageType_kMessageTypePrev:
-      previousSong();
-      sendEvent(EventType::PREV);
+      if (previousSong()) {
+        sendEvent(EventType::PREV);
+      }
       break;
     case MessageType_kMessageTypeLoad: {
       this->trackPlayer->start();
@@ -199,8 +206,8 @@ void SpircHandler::handleFrame(std::vector<uint8_t>& data) {
                                false);
       this->notify();
 
-      trackPlayer->resetState();
       sendEvent(EventType::FLUSH);
+      trackPlayer->resetState();
       break;
     }
     case MessageType_kMessageTypeShuffle: {
@@ -227,34 +234,22 @@ void SpircHandler::notify() {
   this->sendCmd(MessageType_kMessageTypeNotify);
 }
 
-void SpircHandler::skipSong(TrackQueue::SkipDirection dir) {
-  if (trackQueue->skipTrack(dir)) {
-    playbackState->setPlaybackState(PlaybackState::State::Playing);
-    notify();
+bool SpircHandler::skipSong(TrackQueue::SkipDirection dir) {  
+  bool skipped = trackQueue->skipTrack(dir);
 
-    // Reset track state
-    trackPlayer->resetState();
+  // Reset track state
+  trackPlayer->resetState(!skipped);
 
-    sendEvent(EventType::PLAY_PAUSE, false);
-  } else {
-    playbackState->setPlaybackState(PlaybackState::State::Paused);
-    playbackState->updatePositionMs(0);
-    notify();
-
-    sendEvent(EventType::PLAY_PAUSE, true);
-  }
-
-  notify();
-
-  sendEvent(EventType::FLUSH);
+  // send NEXT or PREV event only when successful
+  return skipped;
 }
 
-void SpircHandler::nextSong() {
-  skipSong(TrackQueue::SkipDirection::NEXT);
+bool SpircHandler::nextSong() {
+  return skipSong(TrackQueue::SkipDirection::NEXT);
 }
 
-void SpircHandler::previousSong() {
-  skipSong(TrackQueue::SkipDirection::PREV);
+bool SpircHandler::previousSong() {
+  return skipSong(TrackQueue::SkipDirection::PREV);
 }
 
 std::shared_ptr<TrackPlayer> SpircHandler::getTrackPlayer() {

components/spotify/cspot/src/TrackPlayer.cpp

@@ -87,10 +87,11 @@ void TrackPlayer::stop() {
   std::scoped_lock lock(runningMutex);
 }
 
-void TrackPlayer::resetState() {
+void TrackPlayer::resetState(bool paused) {
   // Mark for reset
   this->pendingReset = true;
   this->currentSongPlaying = false;
+  this->startPaused = paused;
 
   std::scoped_lock lock(dataOutMutex);
 
@@ -119,7 +120,7 @@ void TrackPlayer::runTask() {
   while (isRunning) {
     // Ensure we even have any tracks to play
     if (!this->trackQueue->hasTracks() ||
-        (endOfQueueReached && trackQueue->isFinished())) {
+        (!pendingReset && endOfQueueReached && trackQueue->isFinished())) {
       this->trackQueue->playableSemaphore->twait(300);
       continue;
     }
@@ -184,7 +185,8 @@ void TrackPlayer::runTask() {
       }
 
       if (trackOffset == 0 && pendingSeekPositionMs == 0) {
-        this->trackLoaded(track);
+        this->trackLoaded(track, startPaused);
+        startPaused = false;
       }
 
       int32_t r =

components/spotify/cspot/src/TrackQueue.cpp

@@ -504,11 +504,18 @@ void TrackQueue::processTrack(std::shared_ptr<QueuedTrack> track) {
 
 bool TrackQueue::queueNextTrack(int offset, uint32_t positionMs) {
   const int requestedRefIndex = offset + currentTracksIndex;
+
   if (requestedRefIndex < 0 || requestedRefIndex >= currentTracks.size()) {
     return false;
   }
 
-  if (offset < 0) {
+  // in case we re-queue current track, make sure position is updated (0)
+  if (offset == 0 && preloadedTracks.size() && 
+      preloadedTracks[0]->ref == currentTracks[currentTracksIndex]) {
+      preloadedTracks.pop_front();
+  }
+
+  if (offset <= 0) {
     preloadedTracks.push_front(std::make_shared<QueuedTrack>(
         currentTracks[requestedRefIndex], ctx, positionMs));
   } else {
@@ -520,42 +527,51 @@ bool TrackQueue::queueNextTrack(int offset, uint32_t positionMs) {
 }
 
 bool TrackQueue::skipTrack(SkipDirection dir, bool expectNotify) {
-  bool canSkipNext = currentTracks.size() > currentTracksIndex + 1;
-  bool canSkipPrev = currentTracksIndex > 0;
-
-  if ((dir == SkipDirection::NEXT && canSkipNext) ||
-      (dir == SkipDirection::PREV && canSkipPrev)) {
+    bool skipped = true;
     std::scoped_lock lock(tracksMutex);
-    if (dir == SkipDirection::NEXT) {
-      preloadedTracks.pop_front();
 
-      if (!queueNextTrack(preloadedTracks.size() + 1)) {
-        CSPOT_LOG(info, "Failed to queue next track");
+    if (dir == SkipDirection::PREV) {
+      uint64_t position = !playbackState->innerFrame.state.has_position_ms ? 0 :
+          playbackState->innerFrame.state.position_ms +
+          ctx->timeProvider->getSyncedTimestamp() -
+          playbackState->innerFrame.state.position_measured_at;
+
+      if (currentTracksIndex > 0 && position < 3000) {
+        queueNextTrack(-1);
+
+        if (preloadedTracks.size() > MAX_TRACKS_PRELOAD) {
+            preloadedTracks.pop_back();
+        }
+
+        currentTracksIndex--;
+      } else {
+        queueNextTrack(0);
       }
-
-      currentTracksIndex++;
     } else {
-      queueNextTrack(-1);
+      if (currentTracks.size() > currentTracksIndex + 1) {
+        preloadedTracks.pop_front();
 
-      if (preloadedTracks.size() > MAX_TRACKS_PRELOAD) {
-        preloadedTracks.pop_back();
-      }
+        if (!queueNextTrack(preloadedTracks.size() + 1)) {
+          CSPOT_LOG(info, "Failed to queue next track");
+        }
 
-      currentTracksIndex--;
+        currentTracksIndex++;
+       } else {
+         skipped = false;
+       }
     }
 
-    // Update frame data
-    playbackState->innerFrame.state.playing_track_index = currentTracksIndex;
+    if (skipped) {
+        // Update frame data
+        playbackState->innerFrame.state.playing_track_index = currentTracksIndex;
 
-    if (expectNotify) {
-      // Reset position to zero
-      notifyPending = true;
+        if (expectNotify) {
+            // Reset position to zero
+            notifyPending = true;
+        }
     }
 
-    return true;
-  }
-
-  return false;
+    return skipped;
 }
 
 bool TrackQueue::hasTracks() {

components/wifi-manager/webapp/dist/src/bootswatch/Gruntfile.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(grunt: any): void;
+export = _exports;

components/wifi-manager/webapp/dist/src/bootswatch/docs/2/Gruntfile.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(grunt: any): void;
+export = _exports;

components/wifi-manager/webapp/dist/src/bootswatch/docs/3/Gruntfile.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(grunt: any): void;
+export = _exports;

components/wifi-manager/webapp/dist/src/bootswatch/docs/_vendor/bootstrap/dist/js/bootstrap.esm.d.ts

@@ -0,0 +1,688 @@
+/**
+ * Class definition
+ */
+export class Alert extends BaseComponent {
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    close(): void;
+    _destroyElement(): void;
+}
+/**
+ * Class definition
+ */
+export class Button extends BaseComponent {
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    toggle(): void;
+}
+/**
+ * Class definition
+ */
+export class Carousel extends BaseComponent {
+    static get Default(): {
+        interval: number;
+        keyboard: boolean;
+        pause: string;
+        ride: boolean;
+        touch: boolean;
+        wrap: boolean;
+    };
+    static get DefaultType(): {
+        interval: string;
+        keyboard: string;
+        pause: string;
+        ride: string;
+        touch: string;
+        wrap: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    _interval: NodeJS.Timeout;
+    _activeElement: any;
+    _isSliding: boolean;
+    touchTimeout: NodeJS.Timeout;
+    _swipeHelper: Swipe;
+    _indicatorsElement: any;
+    next(): void;
+    nextWhenVisible(): void;
+    prev(): void;
+    pause(): void;
+    cycle(): void;
+    _maybeEnableCycle(): void;
+    to(index: any): void;
+    _addEventListeners(): void;
+    _addTouchEventListeners(): void;
+    _keydown(event: any): void;
+    _getItemIndex(element: any): number;
+    _setActiveIndicatorElement(index: any): void;
+    _updateInterval(): void;
+    _slide(order: any, element?: any): void;
+    _isAnimated(): any;
+    _getActive(): any;
+    _getItems(): any[];
+    _clearInterval(): void;
+    _directionToOrder(direction: any): "next" | "prev";
+    _orderToDirection(order: any): "right" | "left";
+}
+/**
+ * Class definition
+ */
+export class Collapse extends BaseComponent {
+    static get Default(): {
+        parent: any;
+        toggle: boolean;
+    };
+    static get DefaultType(): {
+        parent: string;
+        toggle: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    _isTransitioning: boolean;
+    _triggerArray: any[];
+    toggle(): void;
+    show(): void;
+    hide(): void;
+    _isShown(element?: any): any;
+    _getDimension(): "width" | "height";
+    _initializeChildren(): void;
+    _getFirstLevelChildren(selector: any): any[];
+    _addAriaAndCollapsedClass(triggerArray: any, isOpen: any): void;
+}
+/**
+ * Class definition
+ */
+export class Dropdown extends BaseComponent {
+    static get Default(): {
+        autoClose: boolean;
+        boundary: string;
+        display: string;
+        offset: number[];
+        popperConfig: any;
+        reference: string;
+    };
+    static get DefaultType(): {
+        autoClose: string;
+        boundary: string;
+        display: string;
+        offset: string;
+        popperConfig: string;
+        reference: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    static clearMenus(event: any): void;
+    static dataApiKeydownHandler(event: any): void;
+    _popper: Popper.Instance;
+    _parent: any;
+    _menu: any;
+    _inNavbar: boolean;
+    toggle(): void;
+    show(): void;
+    hide(): void;
+    update(): void;
+    _completeHide(relatedTarget: any): void;
+    _createPopper(): void;
+    _isShown(): any;
+    _getPlacement(): "top" | "bottom" | "top-end" | "top-start" | "bottom-end" | "bottom-start" | "left-start" | "right-start";
+    _detectNavbar(): boolean;
+    _getOffset(): any;
+    _getPopperConfig(): any;
+    _selectMenuItem({ key, target }: {
+        key: any;
+        target: any;
+    }): void;
+}
+/**
+ * Class definition
+ */
+export class Modal extends BaseComponent {
+    static get Default(): {
+        backdrop: boolean;
+        focus: boolean;
+        keyboard: boolean;
+    };
+    static get DefaultType(): {
+        backdrop: string;
+        focus: string;
+        keyboard: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any, relatedTarget: any): any;
+    _dialog: any;
+    _backdrop: Backdrop;
+    _focustrap: FocusTrap;
+    _isShown: boolean;
+    _isTransitioning: boolean;
+    _scrollBar: ScrollBarHelper;
+    toggle(relatedTarget: any): void;
+    show(relatedTarget: any): void;
+    hide(): void;
+    handleUpdate(): void;
+    _initializeBackDrop(): Backdrop;
+    _initializeFocusTrap(): FocusTrap;
+    _showElement(relatedTarget: any): void;
+    _addEventListeners(): void;
+    _hideModal(): void;
+    _isAnimated(): any;
+    _triggerBackdropTransition(): void;
+    /**
+     * The following methods are used to handle overflowing modals
+     */
+    _adjustDialog(): void;
+    _resetAdjustments(): void;
+}
+/**
+ * Class definition
+ */
+export class Offcanvas extends BaseComponent {
+    static get Default(): {
+        backdrop: boolean;
+        keyboard: boolean;
+        scroll: boolean;
+    };
+    static get DefaultType(): {
+        backdrop: string;
+        keyboard: string;
+        scroll: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    _isShown: boolean;
+    _backdrop: Backdrop;
+    _focustrap: FocusTrap;
+    toggle(relatedTarget: any): void;
+    show(relatedTarget: any): void;
+    hide(): void;
+    _initializeBackDrop(): Backdrop;
+    _initializeFocusTrap(): FocusTrap;
+    _addEventListeners(): void;
+}
+/**
+ * Class definition
+ */
+export class Popover extends Tooltip {
+    static get Default(): {
+        content: string;
+        offset: number[];
+        placement: string;
+        template: string;
+        trigger: string;
+        allowList: {
+            '*': (string | RegExp)[];
+            a: string[];
+            area: any[];
+            b: any[];
+            br: any[];
+            col: any[];
+            code: any[];
+            div: any[];
+            em: any[];
+            hr: any[];
+            h1: any[];
+            h2: any[];
+            h3: any[];
+            h4: any[];
+            h5: any[];
+            h6: any[];
+            i: any[];
+            img: string[];
+            li: any[];
+            ol: any[];
+            p: any[];
+            pre: any[];
+            s: any[];
+            small: any[];
+            span: any[];
+            sub: any[];
+            sup: any[];
+            strong: any[];
+            u: any[];
+            ul: any[];
+        };
+        animation: boolean;
+        boundary: string;
+        container: boolean;
+        customClass: string;
+        delay: number;
+        fallbackPlacements: string[];
+        html: boolean;
+        popperConfig: any;
+        sanitize: boolean;
+        sanitizeFn: any;
+        selector: boolean;
+        title: string;
+    };
+    static get DefaultType(): {
+        content: string;
+        allowList: string;
+        animation: string;
+        boundary: string;
+        container: string;
+        customClass: string;
+        delay: string;
+        fallbackPlacements: string;
+        html: string;
+        offset: string;
+        placement: string;
+        popperConfig: string;
+        sanitize: string;
+        sanitizeFn: string;
+        selector: string;
+        template: string;
+        title: string;
+        trigger: string;
+    };
+    _isWithContent(): any;
+    _getContentForTemplate(): {
+        ".popover-header": any;
+        ".popover-body": any;
+    };
+    _getContent(): any;
+}
+/**
+ * Class definition
+ */
+export class ScrollSpy extends BaseComponent {
+    static get Default(): {
+        offset: any;
+        rootMargin: string;
+        smoothScroll: boolean;
+        target: any;
+        threshold: number[];
+    };
+    static get DefaultType(): {
+        offset: string;
+        rootMargin: string;
+        smoothScroll: string;
+        target: string;
+        threshold: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    _targetLinks: Map<any, any>;
+    _observableSections: Map<any, any>;
+    _rootElement: any;
+    _activeTarget: any;
+    _observer: IntersectionObserver;
+    _previousScrollData: {
+        visibleEntryTop: number;
+        parentScrollTop: number;
+    };
+    refresh(): void;
+    _maybeEnableSmoothScroll(): void;
+    _getNewObserver(): IntersectionObserver;
+    _observerCallback(entries: any): void;
+    _initializeTargetsAndObservables(): void;
+    _process(target: any): void;
+    _activateParents(target: any): void;
+    _clearActiveClass(parent: any): void;
+}
+/**
+ * Class definition
+ */
+export class Tab extends BaseComponent {
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    constructor(element: any);
+    _parent: any;
+    show(): void;
+    _activate(element: any, relatedElem: any): void;
+    _deactivate(element: any, relatedElem: any): void;
+    _keydown(event: any): void;
+    _getChildren(): any[];
+    _getActiveElem(): any;
+    _setInitialAttributes(parent: any, children: any): void;
+    _setInitialAttributesOnChild(child: any): void;
+    _setInitialAttributesOnTargetPanel(child: any): void;
+    _toggleDropDown(element: any, open: any): void;
+    _setAttributeIfNotExists(element: any, attribute: any, value: any): void;
+    _elemIsActive(elem: any): any;
+    _getInnerElement(elem: any): any;
+    _getOuterElement(elem: any): any;
+}
+/**
+ * Class definition
+ */
+export class Toast extends BaseComponent {
+    static get Default(): {
+        animation: boolean;
+        autohide: boolean;
+        delay: number;
+    };
+    static get DefaultType(): {
+        animation: string;
+        autohide: string;
+        delay: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    _timeout: NodeJS.Timeout;
+    _hasMouseInteraction: boolean;
+    _hasKeyboardInteraction: boolean;
+    show(): void;
+    hide(): void;
+    isShown(): any;
+    _maybeScheduleHide(): void;
+    _onInteraction(event: any, isInteracting: any): void;
+    _setListeners(): void;
+    _clearTimeout(): void;
+}
+/**
+ * Class definition
+ */
+export class Tooltip extends BaseComponent {
+    static get Default(): {
+        allowList: {
+            '*': (string | RegExp)[];
+            a: string[];
+            area: any[];
+            b: any[];
+            br: any[];
+            col: any[];
+            code: any[];
+            div: any[];
+            em: any[];
+            hr: any[];
+            h1: any[];
+            h2: any[];
+            h3: any[];
+            h4: any[];
+            h5: any[];
+            h6: any[];
+            i: any[];
+            img: string[];
+            li: any[];
+            ol: any[];
+            p: any[];
+            pre: any[];
+            s: any[];
+            small: any[];
+            span: any[];
+            sub: any[];
+            sup: any[];
+            strong: any[];
+            u: any[];
+            ul: any[];
+        };
+        animation: boolean;
+        boundary: string;
+        container: boolean;
+        customClass: string;
+        delay: number;
+        fallbackPlacements: string[];
+        html: boolean;
+        offset: number[];
+        placement: string;
+        popperConfig: any;
+        sanitize: boolean;
+        sanitizeFn: any;
+        selector: boolean;
+        template: string;
+        title: string;
+        trigger: string;
+    };
+    static get DefaultType(): {
+        allowList: string;
+        animation: string;
+        boundary: string;
+        container: string;
+        customClass: string;
+        delay: string;
+        fallbackPlacements: string;
+        html: string;
+        offset: string;
+        placement: string;
+        popperConfig: string;
+        sanitize: string;
+        sanitizeFn: string;
+        selector: string;
+        template: string;
+        title: string;
+        trigger: string;
+    };
+    static get NAME(): string;
+    static jQueryInterface(config: any): any;
+    _isEnabled: boolean;
+    _timeout: number;
+    _isHovered: boolean;
+    _activeTrigger: {};
+    _popper: Popper.Instance;
+    _templateFactory: TemplateFactory;
+    _newContent: any;
+    tip: Element;
+    enable(): void;
+    disable(): void;
+    toggleEnabled(): void;
+    toggle(): void;
+    show(): void;
+    hide(): void;
+    update(): void;
+    _isWithContent(): boolean;
+    _getTipElement(): Element;
+    _createTipElement(content: any): Element;
+    setContent(content: any): void;
+    _getTemplateFactory(content: any): TemplateFactory;
+    _getContentForTemplate(): {
+        ".tooltip-inner": any;
+    };
+    _getTitle(): any;
+    _initializeOnDelegatedTarget(event: any): any;
+    _isAnimated(): any;
+    _isShown(): boolean;
+    _createPopper(tip: any): Popper.Instance;
+    _getOffset(): any;
+    _resolvePossibleFunction(arg: any): any;
+    _getPopperConfig(attachment: any): any;
+    _setListeners(): void;
+    _hideModalHandler: () => void;
+    _fixTitle(): void;
+    _enter(): void;
+    _leave(): void;
+    _setTimeout(handler: any, timeout: any): void;
+    _isWithActiveTrigger(): boolean;
+    _getDelegateConfig(): {
+        selector: boolean;
+        trigger: string;
+    };
+    _disposePopper(): void;
+}
+/**
+ * Class definition
+ */
+declare class BaseComponent extends Config {
+    static getInstance(element: any): any;
+    static getOrCreateInstance(element: any, config?: {}): any;
+    static get VERSION(): string;
+    static get DATA_KEY(): string;
+    static get EVENT_KEY(): string;
+    static eventName(name: any): string;
+    constructor(element: any, config: any);
+    _element: any;
+    _config: any;
+    dispose(): void;
+    _queueCallback(callback: any, element: any, isAnimated?: boolean): void;
+}
+/**
+ * Class definition
+ */
+declare class Swipe extends Config {
+    static get Default(): {
+        endCallback: any;
+        leftCallback: any;
+        rightCallback: any;
+    };
+    static get DefaultType(): {
+        endCallback: string;
+        leftCallback: string;
+        rightCallback: string;
+    };
+    static get NAME(): string;
+    static isSupported(): boolean;
+    constructor(element: any, config: any);
+    _element: any;
+    _config: any;
+    _deltaX: number;
+    _supportPointerEvents: boolean;
+    dispose(): void;
+    _start(event: any): void;
+    _end(event: any): void;
+    _move(event: any): void;
+    _handleSwipe(): void;
+    _initEvents(): void;
+    _eventIsPointerPenTouch(event: any): boolean;
+}
+import * as Popper from "@popperjs/core";
+/**
+ * Class definition
+ */
+declare class Backdrop extends Config {
+    static get Default(): {
+        className: string;
+        clickCallback: any;
+        isAnimated: boolean;
+        isVisible: boolean;
+        rootElement: string;
+    };
+    static get DefaultType(): {
+        className: string;
+        clickCallback: string;
+        isAnimated: string;
+        isVisible: string;
+        rootElement: string;
+    };
+    static get NAME(): string;
+    constructor(config: any);
+    _config: any;
+    _isAppended: boolean;
+    _element: HTMLDivElement;
+    show(callback: any): void;
+    hide(callback: any): void;
+    dispose(): void;
+    _getElement(): HTMLDivElement;
+    _append(): void;
+    _emulateAnimation(callback: any): void;
+}
+/**
+ * Class definition
+ */
+declare class FocusTrap extends Config {
+    static get Default(): {
+        autofocus: boolean;
+        trapElement: any;
+    };
+    static get DefaultType(): {
+        autofocus: string;
+        trapElement: string;
+    };
+    static get NAME(): string;
+    constructor(config: any);
+    _config: any;
+    _isActive: boolean;
+    _lastTabNavDirection: string;
+    activate(): void;
+    deactivate(): void;
+    _handleFocusin(event: any): void;
+    _handleKeydown(event: any): void;
+}
+/**
+ * Class definition
+ */
+declare class ScrollBarHelper {
+    _element: HTMLElement;
+    getWidth(): number;
+    hide(): void;
+    reset(): void;
+    isOverflowing(): boolean;
+    _disableOverFlow(): void;
+    _setElementAttributes(selector: any, styleProperty: any, callback: any): void;
+    _saveInitialAttribute(element: any, styleProperty: any): void;
+    _resetElementAttributes(selector: any, styleProperty: any): void;
+    _applyManipulationCallback(selector: any, callBack: any): void;
+}
+/**
+ * Class definition
+ */
+declare class TemplateFactory extends Config {
+    static get Default(): {
+        allowList: {
+            '*': (string | RegExp)[];
+            a: string[];
+            area: any[];
+            b: any[];
+            br: any[];
+            col: any[];
+            code: any[];
+            div: any[];
+            em: any[];
+            hr: any[];
+            h1: any[];
+            h2: any[];
+            h3: any[];
+            h4: any[];
+            h5: any[];
+            h6: any[];
+            i: any[];
+            img: string[];
+            li: any[];
+            ol: any[];
+            p: any[];
+            pre: any[];
+            s: any[];
+            small: any[];
+            span: any[];
+            sub: any[];
+            sup: any[];
+            strong: any[];
+            u: any[];
+            ul: any[];
+        };
+        content: {};
+        extraClass: string;
+        html: boolean;
+        sanitize: boolean;
+        sanitizeFn: any;
+        template: string;
+    };
+    static get DefaultType(): {
+        allowList: string;
+        content: string;
+        extraClass: string;
+        html: string;
+        sanitize: string;
+        sanitizeFn: string;
+        template: string;
+    };
+    static get NAME(): string;
+    constructor(config: any);
+    _config: any;
+    getContent(): any[];
+    hasContent(): boolean;
+    changeContent(content: any): TemplateFactory;
+    toHtml(): Element;
+    _typeCheckConfig(config: any): void;
+    _checkContent(arg: any): void;
+    _setContent(template: any, content: any, selector: any): void;
+    _maybeSanitize(arg: any): any;
+    _resolvePossibleFunction(arg: any): any;
+    _putElementInTemplate(element: any, templateElement: any): void;
+}
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap util/config.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+/**
+ * Class definition
+ */
+declare class Config {
+    static get Default(): {};
+    static get DefaultType(): {};
+    static get NAME(): void;
+    _getConfig(config: any): any;
+    _configAfterMerge(config: any): any;
+    _mergeConfigObj(config: any, element: any): any;
+    _typeCheckConfig(config: any, configTypes?: any): void;
+}
+export {};

components/wifi-manager/webapp/dist/src/bootswatch/docs/_vendor/prismjs/prism.d.ts

@@ -0,0 +1,93 @@
+/// <reference lib="webworker" />
+export namespace languages {
+    export namespace markup {
+        namespace tag { }
+    }
+    import html = markup;
+    export { html };
+    import mathml = markup;
+    export { mathml };
+    import svg = markup;
+    export { svg };
+    export const xml: {
+        [x: string]: RegExp | GrammarToken | (RegExp | GrammarToken)[];
+    };
+    import ssml = xml;
+    export { ssml };
+    import atom = xml;
+    export { atom };
+    import rss = xml;
+    export { rss };
+    export const clike: {
+        comment: {
+            pattern: RegExp;
+            lookbehind: boolean;
+            greedy: boolean;
+        }[];
+        string: {
+            pattern: RegExp;
+            greedy: boolean;
+        };
+        'class-name': {
+            pattern: RegExp;
+            lookbehind: boolean;
+            inside: {
+                punctuation: RegExp;
+            };
+        };
+        keyword: RegExp;
+        boolean: RegExp;
+        function: RegExp;
+        number: RegExp;
+        operator: RegExp;
+        punctuation: RegExp;
+    };
+    export const javascript: {
+        [x: string]: RegExp | GrammarToken | (RegExp | GrammarToken)[];
+    };
+    import js = javascript;
+    export { js };
+}
+/**
+ * The expansion of a simple `RegExp` literal to support additional properties.
+ */
+export type GrammarToken = {
+    /**
+     * The regular expression of the token.
+     */
+    pattern: RegExp;
+    /**
+     * If `true`, then the first capturing group of `pattern` will (effectively)
+     * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.
+     */
+    lookbehind?: boolean;
+    /**
+     * Whether the token is greedy.
+     */
+    greedy?: boolean;
+    /**
+     * An optional alias or list of aliases.
+     */
+    alias?: string | string[];
+    /**
+     * The nested grammar of this token.
+     *
+     * The `inside` grammar will be used to tokenize the text value of each token of this kind.
+     *
+     * This can be used to make nested and even recursive language definitions.
+     *
+     * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into
+     * each another.
+     */
+    inside?: Grammar;
+};
+export type Grammar = {
+    [x: string]: RegExp | GrammarToken | Array<RegExp | GrammarToken>;
+};
+/**
+ * A function which will invoked after an element was successfully highlighted.
+ */
+export type HighlightCallback = (element: Element) => void;
+export type HookCallback = (env: {
+    [x: string]: any;
+}) => void;

components/wifi-manager/webapp/dist/src/js/test.d.ts

@@ -63,6 +63,8 @@ declare function getStatus(): {};
 declare function getStatus(): {};
 declare function getStatus(): {};
 declare function getStatus(): {};
+declare function getStatus(): {};
+declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
 declare function getRadioButton(entry: any): string;
@@ -193,6 +195,7 @@ declare function pushStatus(): void;
 declare function pushStatus(): void;
 declare function pushStatus(): void;
 declare function pushStatus(): void;
+declare function pushStatus(): void;
 declare let sd: {};
 declare let rf: boolean;
 declare function refreshStatus(): void;

components/wifi-manager/webapp/webapp.cmake

@@ -1,5 +1,5 @@
-target_add_binary_data( __idf_wifi-manager webapp/dist/css/index.99c86edb045064f0ff9e.css.gz BINARY)
+target_add_binary_data( __idf_wifi-manager webapp/dist/css/index.1ab179394339385e0a02.css.gz BINARY)
 target_add_binary_data( __idf_wifi-manager webapp/dist/favicon-32x32.png BINARY)
 target_add_binary_data( __idf_wifi-manager webapp/dist/index.html.gz BINARY)
-target_add_binary_data( __idf_wifi-manager webapp/dist/js/index.35c7f4.bundle.js.gz BINARY)
-target_add_binary_data( __idf_wifi-manager webapp/dist/js/node_vendors.35c7f4.bundle.js.gz BINARY)
+target_add_binary_data( __idf_wifi-manager webapp/dist/js/index.b02584.bundle.js.gz BINARY)
+target_add_binary_data( __idf_wifi-manager webapp/dist/js/node_vendors.b02584.bundle.js.gz BINARY)

components/wifi-manager/webapp/webpack.c

@@ -1,34 +1,34 @@
 // Automatically generated. Do not edit manually!.
 #include <inttypes.h>
-extern const uint8_t _index_99c86edb045064f0ff9e_css_gz_start[] asm("_binary_index_99c86edb045064f0ff9e_css_gz_start");
-extern const uint8_t _index_99c86edb045064f0ff9e_css_gz_end[] asm("_binary_index_99c86edb045064f0ff9e_css_gz_end");
+extern const uint8_t _index_1ab179394339385e0a02_css_gz_start[] asm("_binary_index_1ab179394339385e0a02_css_gz_start");
+extern const uint8_t _index_1ab179394339385e0a02_css_gz_end[] asm("_binary_index_1ab179394339385e0a02_css_gz_end");
 extern const uint8_t _favicon_32x32_png_start[] asm("_binary_favicon_32x32_png_start");
 extern const uint8_t _favicon_32x32_png_end[] asm("_binary_favicon_32x32_png_end");
 extern const uint8_t _index_html_gz_start[] asm("_binary_index_html_gz_start");
 extern const uint8_t _index_html_gz_end[] asm("_binary_index_html_gz_end");
-extern const uint8_t _index_35c7f4_bundle_js_gz_start[] asm("_binary_index_35c7f4_bundle_js_gz_start");
-extern const uint8_t _index_35c7f4_bundle_js_gz_end[] asm("_binary_index_35c7f4_bundle_js_gz_end");
-extern const uint8_t _node_vendors_35c7f4_bundle_js_gz_start[] asm("_binary_node_vendors_35c7f4_bundle_js_gz_start");
-extern const uint8_t _node_vendors_35c7f4_bundle_js_gz_end[] asm("_binary_node_vendors_35c7f4_bundle_js_gz_end");
+extern const uint8_t _index_b02584_bundle_js_gz_start[] asm("_binary_index_b02584_bundle_js_gz_start");
+extern const uint8_t _index_b02584_bundle_js_gz_end[] asm("_binary_index_b02584_bundle_js_gz_end");
+extern const uint8_t _node_vendors_b02584_bundle_js_gz_start[] asm("_binary_node_vendors_b02584_bundle_js_gz_start");
+extern const uint8_t _node_vendors_b02584_bundle_js_gz_end[] asm("_binary_node_vendors_b02584_bundle_js_gz_end");
 const char * resource_lookups[] = {
-	"/css/index.99c86edb045064f0ff9e.css.gz",
+	"/css/index.1ab179394339385e0a02.css.gz",
 	"/favicon-32x32.png",
 	"/index.html.gz",
-	"/js/index.35c7f4.bundle.js.gz",
-	"/js/node_vendors.35c7f4.bundle.js.gz",
+	"/js/index.b02584.bundle.js.gz",
+	"/js/node_vendors.b02584.bundle.js.gz",
 ""
 };
 const uint8_t * resource_map_start[] = {
-	_index_99c86edb045064f0ff9e_css_gz_start,
+	_index_1ab179394339385e0a02_css_gz_start,
 	_favicon_32x32_png_start,
 	_index_html_gz_start,
-	_index_35c7f4_bundle_js_gz_start,
-	_node_vendors_35c7f4_bundle_js_gz_start
+	_index_b02584_bundle_js_gz_start,
+	_node_vendors_b02584_bundle_js_gz_start
 };
 const uint8_t * resource_map_end[] = {
-	_index_99c86edb045064f0ff9e_css_gz_end,
+	_index_1ab179394339385e0a02_css_gz_end,
 	_favicon_32x32_png_end,
 	_index_html_gz_end,
-	_index_35c7f4_bundle_js_gz_end,
-	_node_vendors_35c7f4_bundle_js_gz_end
+	_index_b02584_bundle_js_gz_end,
+	_node_vendors_b02584_bundle_js_gz_end
 };

components/wifi-manager/webapp/webpack.h

@@ -1,6 +1,6 @@
 /***********************************
 webpack_headers
-dist/css/index.99c86edb045064f0ff9e.css.gz,dist/favicon-32x32.png,dist/index.html.gz,dist/js/index.35c7f4.bundle.js.gz,dist/js/node_vendors.35c7f4.bundle.js.gz
+dist/css/index.1ab179394339385e0a02.css.gz,dist/favicon-32x32.png,dist/index.html.gz,dist/js/index.b02584.bundle.js.gz,dist/js/node_vendors.b02584.bundle.js.gz
 ***********************************/
 #pragma once
 #include <inttypes.h>