Upload 221 files

.gitattributes

@@ -61,3 +61,4 @@ stable-diffusion-webui-reForge/extensions-builtin/forge_legacy_preprocessors/ann
 stable-diffusion-webui-reForge/modules/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text
 extensions-builtin/forge_legacy_preprocessors/annotator/clipvision/clip_vision_h_uc.data filter=lfs diff=lfs merge=lfs -text
 modules/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-infinite-image-browsing/vue/src-tauri/icons/icon.icns filter=lfs diff=lfs merge=lfs -text

extensions/sd-webui-infinite-image-browsing/.env.example

@@ -0,0 +1,49 @@
+# This document is used for additional control over the security and privacy of IIB. By default, IIB is already sufficiently secure, and you do not need to take any additional actions.
+# Copy this file and rename it to ".env"  . Then, fill in the necessary values for your specific use case.
+# Remember to never share your .env file with anyone else as it may contain sensitive information.
+
+# This attribute is used for authentication. If you input a key here, it will be validated for authentication purposes.
+# It will be prompted to enter your key when you open the extension. If the authentication fails, all your requests will be rejected.
+IIB_SECRET_KEY=
+
+# Configuring the server-side language for this extension,
+# including the tab title and most of the server-side error messages returned. Options are 'zh', 'en', or 'auto'.
+# If you want to configure the language for the front-end pages, please set it on the extension's global settings page.
+IIB_SERVER_LANG=auto
+
+# This configuration parameter specifies the maximum number of database file backups for the IIB .
+IIB_DB_FILE_BACKUP_MAX=8
+
+# Set the cache directory for IIB, including image cache and video cover cache.
+# The default is the system's temporary directory, but if you want to specify a custom directory, set it here.
+# You can use --generate_video_cover and --generate_image_cache to pre-generate the cache.
+# IIB_CACHE_DIR=
+
+
+# ---------------------------- ACCESS_CONTROL ----------------------------
+
+# Used to configure whether to enable access control to the file system.
+# If enabled, only access to the provided pre-set folders (including those provided by sd-webui and manually \
+# added to Quick Move or specified via IIB_ACCESS_CONTROL_ALLOWED_PATHS) will be allowed.
+# The available options are 'enable', 'disable', and 'auto'.
+# The default value is 'auto', which will be determined based on the command-line parameters used to start sd-webui (such as --server-name, --share, --listen).
+IIB_ACCESS_CONTROL=auto
+
+# This variable is used to define a list of allowed paths for the application to access when access control mode is enabled. 
+# It can be set to a comma-separated string of file paths or directory paths, representing the resources that are allowed to be accessed by the application.
+# In addition, if sd_webui_config or sd_webui_dir has been configured, or if you're running this repository as an extension of sd-webui, 
+# you can use the following shortcuts (txt2img, img2img, extra, save) as values for the ALLOWED_PATHS variable.
+# IIB_ACCESS_CONTROL_ALLOWED_PATHS=save,extra,/output   ...etc
+
+# This variable is used to control fine-grained access control for different types of requests, but only if access control mode is enabled. 
+# It can be set to a string value that represents a specific permission or set of permissions, such as "read-only", "write-only", "read-write", or "no-access". 
+# This variable can be used to restrict access to certain API endpoints or data sources based on the permissions required by the user. 
+# IIB_ACCESS_CONTROL_PERMISSION=read-write
+
+
+
+# ---------------------------- PARSER_CONFIG ----------------------------
+# This attribute is used to control whether to enable SdWebUIStealthParser.
+# Due to the high performance cost of parsing this type of file, it is disabled by default.
+# Set to 'true' to enable it.
+IIB_ENABLE_SD_WEBUI_STEALTH_PARSER=false

extensions/sd-webui-infinite-image-browsing/.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+ko_fi: zanllp
+custom: https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/.github/wechat_funding.jpg

extensions/sd-webui-infinite-image-browsing/.github/workflows/tauri_app_build.yml

@@ -0,0 +1,231 @@
+name: tauri_app_build
+
+on:
+  push:
+    branches:    
+      - 'releases/**'
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [windows-latest,ubuntu-20.04]
+
+    runs-on: ${{ matrix.os }}
+
+    permissions:
+      contents: write
+    steps:
+      - name: Check-out repository
+        uses: actions/checkout@v3
+
+      - run: echo "VERSION=$(jq -r '.package.version' vue/src-tauri/tauri.conf.json)" >> "$GITHUB_ENV"
+        if: matrix.os == 'ubuntu-20.04'
+      - run: echo "VERSION=$(jq -r '.package.version' vue/src-tauri/tauri.conf.json)" >> $env:GITHUB_ENV
+        if: matrix.os == 'windows-latest'
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10' 
+          cache: 'pip'
+          cache-dependency-path: |
+            **/requirements*.txt
+
+      - name: Install Dependencies
+        run: |
+          
+          pip install -r requirements.txt
+
+      - name: Build Executable
+        uses: Nuitka/Nuitka-Action@main
+        with:
+          nuitka-version: main
+          script-name: app.py
+          output-file: iib_api_server
+          output-dir: out
+          include-data-dir: |
+            vue/dist=vue/dist
+      
+      - run: cp out/iib_api_server out/iib_app_cli-${{ env.VERSION }}-${{ runner.os }}
+        if: matrix.os == 'ubuntu-20.04'
+      - run: cp out/iib_api_server.exe out/iib_app_cli-${{ env.VERSION }}-${{ runner.os }}.exe
+        if: matrix.os == 'windows-latest'
+      
+      - name: Upload Server Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: iib_app_cli_${{ runner.os }}
+          path: |
+            out/iib_app_cli-${{ env.VERSION }}-${{ runner.os }}
+            out/iib_app_cli-${{ env.VERSION }}-${{ runner.os }}.exe
+
+      - name: Upload Server Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: iib_api_server-${{ env.VERSION }}-${{ runner.os }}
+          path: |
+            out/iib_api_server.exe
+            out/iib_api_server
+      
+      - run: mv out/iib_api_server.exe vue/src-tauri/iib_api_server-x86_64-pc-windows-msvc.exe
+        if: matrix.os == 'windows-latest'
+
+      - run: mv out/iib_api_server vue/src-tauri/iib_api_server-x86_64-unknown-linux-gnu
+        if: matrix.os == 'ubuntu-20.04'
+
+      - name: Install frontend dependencies
+        run: yarn install
+        working-directory: vue
+
+      - name: Rust setup
+        uses: dtolnay/rust-toolchain@stable
+        
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: './vue/src-tauri -> target'
+
+      - name: Install dependencies (ubuntu only)
+        if: matrix.os == 'ubuntu-20.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libayatana-appindicator3-dev librsvg2-dev patchelf
+
+      - name: Build the app
+        run: |
+          yarn tauri-build
+        working-directory: vue
+      
+      
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: bundle-${{ env.VERSION }}-${{ runner.os }}
+          path: |
+            vue/src-tauri/target/release/bundle/nsis/Infinite Image Browsing_${{ env.VERSION }}_x64-setup.exe
+            vue/src-tauri/target/release/bundle/deb/infinite-image-browsing_${{ env.VERSION }}_amd64.deb
+
+
+  build-by-pyinstaller:
+    strategy:
+      matrix:
+        os: [windows-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    permissions:
+      contents: write
+    steps:
+      - name: Check-out repository
+        uses: actions/checkout@v3
+
+      - run: echo "VERSION=$(jq -r '.package.version' vue/src-tauri/tauri.conf.json)" >> $env:GITHUB_ENV
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10' 
+          cache: 'pip'
+          cache-dependency-path: |
+            **/requirements*.txt
+
+      - name: Install Dependencies
+        run: |
+          pip install -r requirements.txt
+
+      - uses: sayyid5416/pyinstaller@v1
+        with:
+            spec: 'app.py'
+            upload_exe_with_name: 'My executable'
+            options: --onefile
+
+      - run: mv dist/app.exe vue/src-tauri/iib_api_server-x86_64-pc-windows-msvc.exe
+
+      - name: Install frontend dependencies
+        run: yarn install
+        working-directory: vue
+
+      - name: Rust setup
+        uses: dtolnay/rust-toolchain@stable
+        
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: './vue/src-tauri -> target'
+
+      - name: Install dependencies (ubuntu only)
+        if: matrix.os == 'ubuntu-20.04'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libayatana-appindicator3-dev librsvg2-dev patchelf
+
+      - name: Build the app
+        run: |
+          yarn tauri-build
+        working-directory: vue
+      
+      - run: |
+         cd vue/src-tauri/target/release/bundle/nsis
+         mv "Infinite Image Browsing_${{ env.VERSION }}_x64-setup.exe" "Infinite Image Browsing_${{ env.VERSION }}_x64-setup-pyinstaller.exe"
+      
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: bundle-${{ env.VERSION }}-${{ runner.os }}
+          path: |
+            vue/src-tauri/target/release/bundle/nsis/Infinite Image Browsing_${{ env.VERSION }}_x64-setup-pyinstaller.exe
+            
+  release:
+    needs: [build-by-pyinstaller, build]
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+    steps:
+      - name: Check-out repository
+        uses: actions/checkout@v3
+      - run: echo "VERSION=$(jq -r '.package.version' vue/src-tauri/tauri.conf.json)" >> "$GITHUB_ENV"
+
+      - name: Delete drafts
+        uses: hugo19941994/[email protected]
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: bundle-${{ env.VERSION }}-Windows
+          path: artifacts
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: bundle-${{ env.VERSION }}-Linux
+          path: artifacts
+      
+      - uses: actions/download-artifact@v3
+        with:
+          name: iib_app_cli_Windows
+          path: artifacts
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: iib_app_cli_Linux
+          path: artifacts
+
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        with:
+          draft: true
+          tag_name: v${{ env.VERSION }}
+          files: artifacts/**/*
+          

extensions/sd-webui-infinite-image-browsing/.gitignore

@@ -0,0 +1,22 @@
+*.log
+__pycache__
+iib.db
+tags-translate.csv
+launch.sh
+conf.json
+iib.db-journal
+.env
+standalone.cmd
+.vscode
+build/**/*
+dist/**/*
+*.spec
+out/**/*
+venv/**/*
+zip_temp/*.zip
+iib_db_backup
+db_migrate_temp.db
+plugins/*
+!plugins/.gitkeep
+test_data/*
+.DS_Store

extensions/sd-webui-infinite-image-browsing/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "[python]": {
+    "editor.defaultFormatter": "ms-python.black-formatter"
+  },
+  "python.formatting.provider": "none"
+}

extensions/sd-webui-infinite-image-browsing/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 zanllp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extensions/sd-webui-infinite-image-browsing/README-zh.md

@@ -0,0 +1,162 @@
+> 🌐 在线体验： http://39.105.110.128:0721   ， 这是我一个空闲的2c2g3m的云主机没有cdn
+> 
+# Stable-Diffusion-WebUI无边图像浏览
+
+
+[查看近期更新](https://github.com/zanllp/sd-webui-infinite-image-browsing/wiki/Change-log)
+
+[安装/运行](#安装运行)
+
+
+## 主要特性
+
+### 🔥 极佳性能
+- 存在缓存的情况下后，图像可以在几毫秒内显示。
+- 默认使用缩略图显示图像，默认大小为512像素，您可以在全局设置页中调整缩略图分辨率。
+- 你还可以控制网格图像的宽度，允许以64px到1024px的宽度范围进行显示
+- 支持通过`--generate_video_cover`和`--generate_image_cache`来预先生成缩略图和视频封面，以提高性能。
+- 支持通过`IIB_CACHE_DIR`环境变量来指定缓存目录。
+
+### 🔍 图像搜索和收藏
+- 将会把Prompt、Model、Lora等信息转成标签，将根据使用频率排序以供进行精确的搜索。
+- 支持标签自动完成、[翻译](https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/39)和自定义。
+- 可通过在右键菜单切换自定义标签来实现图像收藏。
+- 支持类似谷歌的高级搜索。
+- 同样支持模糊搜索，您可以使用文件名或生成信息的一部分进行搜索。
+- 支持添加自定义搜索路径，方便管理自己创建的文件夹集合。
+
+### 🖼️ 查看图像/视频和“发送到”
+- 支持查看图像生成信息。全屏预览下同样支持。
+- 支持将图像发送到其他选项卡和其他插件，例如 ControlNet, openOutpaint。
+- 支持全屏预览，并且支持在全屏预览下使用自定义快捷键进行操作
+- 支持在全屏预览模式下通过按下方向键或点击按钮移动到前一个或后一个图像。
+- 支持播放远程服务器上的视频文件
+
+### 💻 多种使用方法
+- 您可以将其作为 SD-webui 的扩展安装。
+- 您可以使用 Python 独立运行它。
+- 还提供桌面应用程序版本。
+- 支持多种流行的AI软件
+
+### 🚶‍♀️ Walk模式
+- 自动加载下一个文件夹 `(类似于 os.walk)`，可让您无需分页浏览所有图像。
+- 已测试可正常处理超过 27,000 个文件。
+- 当存在文件夹的情况下你可以通过右上角的walk按钮从其他模式切换到walk模式，它会将所有的文件夹打平，避免来回进出文件夹的繁琐操作。
+
+### 🌳 基于文件树结构的预览和文件操作
+- 支持基于文件树结构的预览。
+- 支持自动刷新。
+- 支持基本文件操作以及多选删除/移动/复制，新建文件夹等。
+- 按住 Ctrl、Shift 或 Cmd 键可选择多个项目。
+  - 支持多选的操作有：删除、移动、复制、打包下载、添加标签、移除标签，移动到其他文件夹，复制到其他文件夹，拖拽
+  - 你可以通过右下角的保持多选按钮来保持多选的状态，对选中的文件集合可以很方便的进行多次操作
+
+### 🆚 图像对比 (类似ImgSli)
+- 提供两张图片的并排比较
+- 同时提供图像生成信息的比较
+
+### 🌐 多语言支持
+- 目前支持简体中文/繁体中文/英文/德语。
+- 如果您希望添加新的语言，请参考 [i18n.ts](https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/vue/src/i18n/zh-hans.ts) 并提交相关的代码。
+
+
+### 🔐 隐私和安全
+- 支持自定义secret key来进行身份验证
+- 支持配置对文件系统的访问控制，默认将在服务允许公开访问时启用(仅限作为sd-webui的拓展时)
+- 支持自定义访问控制允许的路径。
+- 支持控制访问权限。你可以让IIB以只读模式运行
+- [点击这里查看详情](.env.example)
+
+### ⌨️ 快捷键
+- 支持删除和添加/移除Tag，在全局设置页进行自定义触发按钮
+
+### 📦 打包 / 批量下载
+- 允许你一次性打包下载多个图像
+- 数据来源可以是搜索结果/普通的图像网格查看页面/walk模式等。使用拖拽或者“发送到”都可将图片添加待处理列表
+
+
+如果您喜欢这个项目并且觉得它对您有帮助，请考虑给我点个⭐️。这将对我持续开发和维护这个项目非常重要。如果您有任何建议或者想法，请随时在issue中提出，我会尽快回复。再次感谢您的支持！
+
+
+[在微信上赞助我](.github/wechat_funding.jpg)
+
+<a href='https://ko-fi.com/zanllp' target='_blank'><img height='35' style='border:0px;height:46px;' src='https://az743702.vo.msecnd.net/cdn/kofi3.png?v=0' border='0' alt='Buy Me a Coffee at ko-fi.com' />
+
+
+[视频演示可以在Bilibili上观看](https://space.bilibili.com/27227392/channel/series)
+
+# 安装/运行
+
+## 作为SD-webui的扩展程序:
+1. 在SD-webui中打开`扩展`选项卡。
+2. 选择`从URL安装`选项。
+3. 输入 `https://github.com/zanllp/sd-webui-infinite-image-browsing`。
+4. 点击`安装`按钮。
+5. 等待安装完成，然后点击`应用并重启UI`。
+
+## 作为使用Python运行的独立程序（不需要SD-webui��:
+请参考[Can the extension function without the web UI?](https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/47)
+
+如果需要查看ComfyUI/Fooocus/NovelAI生成的图片相关，请先参考 https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/202#issuecomment-1655764627
+
+如果你需要dockerfile 参考  https://github.com/zanllp/sd-webui-infinite-image-browsing/discussions/366
+
+## 作为桌面应用程序（不需要SD-webui和Python）:
+exe版本同样支持ComfyUI/Fooocus/NovelAI
+
+从仓库页面右侧的`releases`部分下载并安装程序。如果提示检测到病毒忽略即可这是误报。在windows下的编译有两个版本, pyinstaller版本拥有比较低的误报率。
+
+如果你需要自行编译请参考 https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/.github/workflows/tauri_app_build.yml
+## 作为库使用
+
+使用iframe接入IIB，将IIB作为你应用的文件浏览器使用。 参考 https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/vue/usage.md
+
+# 预览
+
+<img width="1920" alt="image" src="https://user-images.githubusercontent.com/25872019/230064374-47ba209e-562b-47b8-a2ce-d867e3afe204.png">
+
+## 图像搜索
+
+在第一次使用时，你需要点击等待索引的生成，我2万张图像的情况下大概需要15秒（配置是amd 5600x和pcie ssd）。后续使用他会检查文件夹是否发生变化，如果发生变化则需要重新生成索引,通常这个过程极快。
+
+图像搜索支持翻译，具体看这个 https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/39 。
+<img width="1109" alt="image" src="https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/62d1ffe3-2d1f-4449-803a-970273753855">
+<img width="620" alt="image" src="https://user-images.githubusercontent.com/25872019/234639759-2d270fe5-b24b-4542-b75a-a025ba78ec89.png">
+## 图像比较
+
+![ezgif com-video-to-gif](https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/4023317b-0b2d-41a3-8155-c4862eb43846)
+
+## 全屏预览 (并排布局)
+![11](https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/ee941bfc-0c1b-4777-91df-115435cc8542)
+
+## 全屏预览
+<img width="1024" alt="image" src="https://user-images.githubusercontent.com/25872019/232167416-32a8b19d-b766-4f98-88f6-a1d48eaebec0.png">
+
+在全屏预览下同样可以查看图片信息和进行上下文菜单上的的操作，支持拖拽/调整/展开收起
+
+https://user-images.githubusercontent.com/25872019/235327735-bfb50ea7-7682-4e50-b303-38159456e527.mp4
+
+
+如果你和我一样不需要查看生成信息，你可以选择直接缩小这个面板，所有上下文操作仍然可用
+
+<img width="599" alt="image" src="https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/f26abe8c-7a76-45c3-9d7f-18ae8b6b6a91">
+
+### 右键菜单
+<img width="1024" alt="image" src="https://user-images.githubusercontent.com/25872019/230896820-26344b09-2297-4a2f-a6a7-4c2f0edb8a2c.png">
+
+也可以通过右上角的图标来触发
+<img width="227" alt="image" src="https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/f2005ad3-2d3b-4fa7-b3e5-bc17f26f7e19">
+
+### Walk模式
+
+
+https://user-images.githubusercontent.com/25872019/230768207-daab786b-d4ab-489f-ba6a-e9656bd530b8.mp4
+
+
+
+
+### 深色模式
+
+<img width="768" alt="image" src="https://user-images.githubusercontent.com/25872019/230064879-c95866ac-999d-4d4b-87ea-3e38c8479415.png">
+
+

extensions/sd-webui-infinite-image-browsing/README.md

@@ -0,0 +1,178 @@
+> 🌍 i18n Advisory: Some translations may be incomplete or inaccurate. Pull requests are welcome for improvements!
+
+> 🌐 Try our application online at: http://39.105.110.128:0721. This is my idle 2c2g3m cloud server without CDN.
+
+[中文文档](./README-zh.md)
+[Change log](https://github.com/zanllp/sd-webui-infinite-image-browsing/wiki/Change-log)
+[Installation / Running](#installation--running)
+
+
+#  Stable Diffusion webui Infinite Image Browsing
+
+### Software Support and Development Progress Overview
+| Software               | Support          | Provided by |
+| ---------------------- | ---------------- |  ----------- |
+| Stable Diffusion web UI| Supported        |  Built-in    |
+| Stable Diffusion web UI (Stealth)| Supported  ([default: disabled](https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/.env.example#L49))      |  Built-in    |
+| ComfyUI                | Partially supported |  Built-in    |
+| Fooocus                | Supported        |  Built-in    |
+| NovelAI                | Supported    |  Built-in    |
+| StableSwarmUI          | Supported    |  Built-in    |
+| Invoke.AI          | Supported    |  Built-in    |
+| Pixiv                  | Supported        |  [pixiv_iib_plugin](https://github.com/zanllp/pixiv_iib_plugin) |
+
+If you would like to support more software, please refer to: [parsers](https://github.com/zanllp/sd-webui-infinite-image-browsing/tree/main/scripts/iib/parsers) or [pixiv_iib_plugin](https://github.com/zanllp/pixiv_iib_plugin)
+
+## Key Features
+
+### 🔥 Excellent Performance
+- Once caching is generated, images can be displayed in just a few milliseconds.
+- Images are displayed with thumbnails by default, with a default size of 512 pixels. You can adjust the thumbnail resolution on the global settings page.
+- You can also control the width of the grid images, allowing them to be displayed in widths ranging from 64px to 1024px.
+- Supports pre-generating thumbnails and video covers to improve performance using `--generate_video_cover` and `--generate_image_cache`.
+- Supports specifying the cache directory through the `IIB_CACHE_DIR` environment variable.
+
+### 🔍 Image Search & Favorite
+- The prompt, model, Lora, and other information will be converted into tags and sorted by frequency of use for precise searching.
+- Supports tag autocomplete, [auto-translation](https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/39), and customization.
+- Image favorite can be achieved by toggling custom tags for images in the right-click menu.
+- Support for advanced search similar to Google
+- Also supports fuzzy search, you can search by a part of the filename or generated information.
+- Support adding custom search paths for easy management of folders created by the user.
+
+### 🖼️ View Images/Videos & `Send To`
+- Supports viewing image generation information. Also supported in full-screen preview mode.
+- Supports sending images to other tabs and third-party extensions such as ControlNet , openOutpaint.
+- Support full-screen preview and enable custom shortcut key operations while in full-screen preview mode.
+- Support navigating to the previous or next image in full-screen preview mode by pressing arrow keys or clicking buttons.
+- Support playing video files from a remote server.
+
+### 💻 Multiple Usage Methods
+- You can install it as an extension on SD-webui. 
+- You can run it independently using Python.
+- The desktop app version is also available.
+- Supports multiple popular AI software.
+
+
+### 🚶‍♀️ Walk Mode
+- Automatically load the next folder `(similar to os.walk)`, allowing you to browse all images without paging.
+- Tested to work properly with over 27,000 files.
+- When there are folders, you can switch to walk mode from other modes by clicking the walk button in the upper right corner. It will flatten all the folders, avoiding the tedious operation of going in and out of folders.
+
+### 🌳 Preview based on File Tree Structure & File operations
+- Supports file tree-based preview.
+- Supports automatic refreshing.
+- Supports basic file operations, such as multiple selection for deleting/moving/copying, and creating new folders.
+- Hold down the Ctrl, Shift, or Cmd key to select multiple items.
+  - Supported multi-select operations include: delete, move, copy, pack download, add tags, remove tags, move to another folder, copy to another folder, drag and drop.
+  - You can keep the multi-select state by clicking the "Keep Multi-Select" button in the lower right corner, allowing you to perform multiple operations on the selected file collection conveniently.
+
+### 🆚 image comparison (similar to Imgsli)
+- Provides a side-by-side comparison of two images.
+- Provides a comparison of image generation information at the same time.
+
+### 🌐 Multilingual Support
+- Currently supports Simplified Chinese/Traditional Chinese/English/German.
+- If you would like to add a new language, please refer to [i18n.ts](https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/vue/src/i18n/zh-hans.ts) and submit the relevant code.
+
+### 🔐 Privacy and Security
+- Supports custom secret key for authentication.
+- Supports configuring access control for the file system, which will be enabled by default when the service allows public access (Only when used as an extension of sd-webui).
+- Supports customizing the allowed paths for access control.
+- Supports controlling access permissions. You can run IIB in read-only mode.
+- [Click here to see details](.env.example)
+
+
+### 📦 Packaging/Batch Download
+- Allows you to download multiple images at once.
+- The data source can be search results, a regular image grid view page, walk mode, etc. Images can be added to the processing list through drag-and-drop or "Send To".
+### ⌨️ Keyboard Shortcuts
+- Allows for deleting and adding/removing tags, with customizable trigger buttons in the global settings page.
+
+
+If you like this project and find it helpful, please consider giving it a ⭐️. This would be very important for me to continue developing and maintaining this project. If you have any suggestions or ideas, please feel free to raise them in the issue section, and I will respond as soon as possible. Thank you again for your support!
+
+
+<a href='https://ko-fi.com/zanllp' target='_blank'><img height='35' style='border:0px;height:46px;' src='https://az743702.vo.msecnd.net/cdn/kofi3.png?v=0' border='0' alt='Buy Me a Coffee at ko-fi.com' />
+
+[Sponsor me on WeChat](.github/wechat_funding.jpg)
+
+# Installation / Running
+## As an extension for SD-webui:
+1. Open the `Extensions` tab in SD-webui.
+2. Select the `Install from URL` option.
+3. Enter `https://github.com/zanllp/sd-webui-infinite-image-browsing`.
+4. Click on the `Install` button.
+5. Wait for the installation to complete and click on `Apply and restart UI`.
+
+## As a standalone program that runs using Python. (without SD-webui):
+
+Refer to [Can the extension function without the web UI?](https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/47)
+
+If you need to view images generated by ComfyUI/Fooocus/NovelAI, please refer to [https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/202](https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/202#issuecomment-1655764627).
+
+If you need a Dockerfile, you can refer to this link.  https://github.com/zanllp/sd-webui-infinite-image-browsing/discussions/366
+
+## As a desktop application (without SD-webui and Python):
+The executable version also supports ComfyUI/Fooocus/NovelAI.
+
+Download and install the program from the `releases` section on the right-hand side of the repository page.
+If the antivirus detects a virus, it can be ignored as a false positive. There are two versions of the compiled version for Windows, with the pyinstaller version having a lower false positive rate.
+
+If you need to compile it yourself, please refer to https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/.github/workflows/tauri_app_build.yml.
+
+## As a Library Usage:
+
+Use iframe to access IIB and use it as a file browser for your application. Refer to https://github.com/zanllp/sd-webui-infinite-image-browsing/blob/main/vue/usage.md
+
+
+# Preview
+
+<img width="1920" alt="image" src="https://user-images.githubusercontent.com/25872019/232167682-67f83b00-4391-4394-a7f6-6e4c9d11f252.png">
+
+## Image Search
+
+During the first use, you need to click and wait for the index generation. For my case with 20,000 images, it took about 45 seconds (with an AMD 5600X CPU and PCIe SSD). For subsequent uses, it will check whether there are changes in the folder, and if so, it needs to regenerate the index. Usually, this process is very fast.
+
+Image search supports translation, see https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/39 for more detail. Feel free to share files for other languages to facilitate everyone's use.
+<img width="1109" alt="image" src="https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/62d1ffe3-2d1f-4449-803a-970273753855">
+<img width="620" alt="image" src="https://user-images.githubusercontent.com/25872019/234639759-2d270fe5-b24b-4542-b75a-a025ba78ec89.png">
+
+## Full Screen Preview (Side-by-Side Layout)
+![11](https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/ee941bfc-0c1b-4777-91df-115435cc8542)
+
+## Full Screen Preview
+
+<img width="1024" alt="image" src="https://user-images.githubusercontent.com/25872019/232167416-32a8b19d-b766-4f98-88f6-a1d48eaebec0.png">
+
+In full-screen preview mode, you can also view image information and perform operations on the context menu. It supports dragging, resizing and expanding/collapsing .
+
+https://user-images.githubusercontent.com/25872019/235327735-bfb50ea7-7682-4e50-b303-38159456e527.mp4
+
+If you, like me, don't need to view the generation information, you can choose to simply minimize this panel, and all contextual operations will still be available.
+
+<img width="599" alt="image" src="https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/f26abe8c-7a76-45c3-9d7f-18ae8b6b6a91">
+
+## Image comparison
+
+![ezgif com-video-to-gif](https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/4023317b-0b2d-41a3-8155-c4862eb43846)
+## Transfer files between different tab panes.
+https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/e631e3c3-1cbf-49bc-8577-f2963a6c9e4d
+### Right-click menu
+<img width="536" alt="image" src="https://user-images.githubusercontent.com/25872019/232162244-e728d510-b6c6-45e6-afb3-872bd67db05b.png">
+
+You can also trigger it by hovering your mouse over the icon in the top right corner.
+
+<img width="227" alt="image" src="https://github.com/zanllp/sd-webui-infinite-image-browsing/assets/25872019/f2005ad3-2d3b-4fa7-b3e5-bc17f26f7e19">
+
+### Walk mode
+
+
+https://user-images.githubusercontent.com/25872019/230768207-daab786b-d4ab-489f-ba6a-e9656bd530b8.mp4
+
+
+
+
+### Dark mode
+
+<img width="768" alt="image" src="https://user-images.githubusercontent.com/25872019/230064879-c95866ac-999d-4d4b-87ea-3e38c8479415.png">

extensions/sd-webui-infinite-image-browsing/app.py

@@ -0,0 +1,299 @@
+import codecs
+from typing import List
+from fastapi import FastAPI, Response
+from fastapi.responses import FileResponse
+import uvicorn
+import os
+from scripts.iib.api import infinite_image_browsing_api, index_html_path, DEFAULT_BASE
+from scripts.iib.tool import (
+    get_sd_webui_conf,
+    get_valid_img_dirs,
+    sd_img_dirs,
+    normalize_paths,
+)
+from scripts.iib.db.datamodel import DataBase, Image, ExtraPath
+from scripts.iib.db.update_image_data import update_image_data
+import argparse
+from typing import Optional, Coroutine
+import json
+
+tag = "\033[31m[warn]\033[0m"
+
+default_port = 8000
+default_host = "127.0.0.1"
+
+def get_all_img_dirs(sd_webui_config: str, relative_to_config: bool):
+    dirs = get_valid_img_dirs(
+        get_sd_webui_conf(
+            sd_webui_config=sd_webui_config,
+            sd_webui_path_relative_to_config=relative_to_config,
+        )
+    )
+    dirs += list(map(lambda x: x.path, ExtraPath.get_extra_paths(DataBase.get_conn())))
+    return dirs
+
+
+def sd_webui_paths_check(sd_webui_config: str, relative_to_config: bool):
+    conf = {}
+    with codecs.open(sd_webui_config, "r", "utf-8") as f:
+        conf = json.loads(f.read())
+    if relative_to_config:
+        for dir in sd_img_dirs:
+            if not os.path.isabs(conf[dir]):
+                conf[dir] = os.path.normpath(
+                    os.path.join(sd_webui_config, "../", conf[dir])
+                )
+    paths = [conf.get(key) for key in sd_img_dirs]
+    paths_check(paths)
+
+
+def paths_check(paths):
+    for path in paths:
+        if not path or len(path.strip()) == 0:
+            continue
+        if os.path.isabs(path):
+            abs_path = path
+        else:
+            abs_path = os.path.normpath(os.path.join(os.getcwd(), path))
+        if not os.path.exists(abs_path):
+            print(f"{tag} The path '{abs_path}' will be ignored (value: {path}).")
+
+
+def do_update_image_index(sd_webui_config: str, relative_to_config=False):
+    dirs = get_all_img_dirs(sd_webui_config, relative_to_config)
+    if not len(dirs):
+        return print(f"{tag} no valid image directories, skipped")
+    conn = DataBase.get_conn()
+    update_image_data(dirs)
+    if Image.count(conn=conn) == 0:
+        return print(f"{tag} it appears that there is some issue")
+    print("update image index completed. ✨")
+
+
+class AppUtils:
+    def __init__(
+        self,
+        sd_webui_config: Optional[str] = None,
+        update_image_index: bool = False,
+        extra_paths: List[str] = [],
+        sd_webui_path_relative_to_config=False,
+        allow_cors=False,
+        enable_shutdown=False,
+        sd_webui_dir: Optional[str] = None,
+        base: Optional[str] = None,
+        export_fe_fn=False,
+        **args: dict,
+    ):
+        """
+        Parameter definitions can be found by running the `python app.py -h `command or by examining the setup_parser() function.
+        """
+        self.sd_webui_config = sd_webui_config
+        self.update_image_index = update_image_index
+        self.extra_paths = extra_paths
+        self.sd_webui_path_relative_to_config = sd_webui_path_relative_to_config
+        self.allow_cors = allow_cors
+        self.enable_shutdown = enable_shutdown
+        self.sd_webui_dir = sd_webui_dir
+        if base and not base.startswith("/"):
+            base = "/" + base
+        self.base = base
+        self.export_fe_fn = export_fe_fn
+        if sd_webui_dir:
+            DataBase.path = os.path.join(
+                sd_webui_dir, "extensions/sd-webui-infinite-image-browsing/iib.db"
+            )
+            self.sd_webui_config = os.path.join(sd_webui_dir, "config.json")
+            self.sd_webui_path_relative_to_config = True
+
+    def set_params(self, *args, **kwargs) -> None:
+        """改变参数，与__init__的行为一致"""
+        self.__init__(*args, **kwargs)
+
+    @staticmethod
+    def async_run(
+        app: FastAPI, port: int = default_port, host=default_host
+    ) -> Coroutine:
+        """
+        用于从异步运行的 FastAPI，在 Jupyter Notebook 环境中非常有用
+        """
+        # 不建议改成 async def，并且用 await 替换 return，
+        # 因为这样会失去对 server.serve() 的控制。
+        config = uvicorn.Config(app, host=host, port=port)
+        server = uvicorn.Server(config)
+        return server.serve()
+
+    def wrap_app(self, app: FastAPI) -> None:
+        """
+        为传递的app挂载上infinite_image_browsing后端
+        """
+        sd_webui_config = self.sd_webui_config
+        update_image_index = self.update_image_index
+        extra_paths = self.extra_paths
+
+        if sd_webui_config:
+            sd_webui_paths_check(sd_webui_config, self.sd_webui_path_relative_to_config)
+            if update_image_index:
+                do_update_image_index(
+                    sd_webui_config, self.sd_webui_path_relative_to_config
+                )
+        paths_check(extra_paths)
+
+        infinite_image_browsing_api(
+            app,
+            sd_webui_config=sd_webui_config,
+            extra_paths_cli=normalize_paths(extra_paths, os.getcwd()),
+            sd_webui_path_relative_to_config=self.sd_webui_path_relative_to_config,
+            allow_cors=self.allow_cors,
+            enable_shutdown=self.enable_shutdown,
+            launch_mode="server",
+            base=self.base,
+            export_fe_fn=self.export_fe_fn,
+        )
+
+    def get_root_browser_app(self) -> FastAPI:
+        """
+        获取首页挂载在"/"上的infinite_image_browsing FastAPI实例
+        """
+        app = FastAPI()
+
+        # 用于在首页显示
+        @app.get("/")
+        def index():
+            if isinstance(self.base, str):
+                with open(index_html_path, "r", encoding="utf-8") as file:
+                    content = file.read().replace(DEFAULT_BASE, self.base)
+                    return Response(content=content, media_type="text/html")
+            return FileResponse(index_html_path)
+
+        self.wrap_app(app)
+        return app
+
+
+def setup_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="A fast and powerful image/video browser with infinite scrolling and advanced search capabilities. It also supports parsing/viewing image information generated by multiple AI software."
+    )
+    parser.add_argument(
+        "--host", type=str, default=default_host, help="The host to use"
+    )
+    parser.add_argument(
+        "--port", type=int, help="The port to use", default=default_port
+    )
+    parser.add_argument(
+        "--sd_webui_config", type=str, default=None, help="The path to the config file"
+    )
+    parser.add_argument(
+        "--update_image_index", action="store_true", help="Update the image index"
+    )
+    parser.add_argument(
+        "--generate_video_cover",
+        action="store_true",
+        help="Pre-generate video cover images to speed up browsing.",
+    )
+    parser.add_argument(
+        "--generate_image_cache",
+        action="store_true",
+        help="Pre-generate image cache to speed up browsing. By default, only the extra paths added by the user are processed, not the paths in sd_webui_config. If you need to process paths in sd_webui_config, you must use the --sd_webui_config and --sd_webui_path_relative_to_config parameters.",
+    )
+    parser.add_argument(
+        "--generate_image_cache_size",
+        type=str,
+        default="512x512",
+        help="The size of the image cache to generate. Default is 512x512",
+    )
+    parser.add_argument(
+        "--gen_cache_verbose",
+        action="store_true",
+        help="Verbose mode for cache generation.",
+    )
+    parser.add_argument(
+        "--extra_paths",
+        nargs="+",
+        help="Extra paths to use, these paths will be added to the homepage but the images in these paths will not be indexed. They are only used for browsing. If you need to index them, please add them via the '+ Add' button on the homepage.",
+        default=[],
+    )
+    parser.add_argument(
+        "--sd_webui_path_relative_to_config",
+        action="store_true",
+        help="Use the file path of the sd_webui_config file as the base for all relative paths provided within the sd_webui_config file.",
+    )
+    parser.add_argument(
+        "--allow_cors",
+        action="store_true",
+        help="Allow Cross-Origin Resource Sharing (CORS) for the API.",
+    )
+    parser.add_argument(
+        "--enable_shutdown",
+        action="store_true",
+        help="Enable the shutdown endpoint.",
+    )
+    parser.add_argument(
+        "--sd_webui_dir",
+        type=str,
+        default=None,
+        help="The path to the sd_webui folder. When specified, the sd_webui's configuration will be used and the extension must be installed within the sd_webui. Data will be shared between the two.",
+    )
+    parser.add_argument(
+        "--export_fe_fn",
+        default=True,
+        action="store_true",
+        help="Export front-end functions to enable external access through iframe.",
+    )
+    parser.add_argument("--base", type=str, help="The base URL for the IIB Api.")
+    return parser
+
+
+def launch_app(
+    port: int = default_port, host: str = default_host, *args, **kwargs: dict
+) -> None:
+    """
+    Launches the application on the specified port.
+
+    Args:
+        **kwargs (dict): Optional keyword arguments that can be used to configure the application.
+            These can be viewed by running 'python app.py -h' or by checking the setup_parser() function.
+    """
+    app_utils = AppUtils(*args, **kwargs)
+    app = app_utils.get_root_browser_app()
+    uvicorn.run(app, host=host, port=port)
+
+
+async def async_launch_app(
+    port: int = default_port, host: str = default_host, *args, **kwargs: dict
+) -> None:
+    """
+    Asynchronously launches the application on the specified port.
+
+    Args:
+        **kwargs (dict): Optional keyword arguments that can be used to configure the application.
+            These can be viewed by running 'python app.py -h' or by checking the setup_parser() function.
+    """
+    app_utils = AppUtils(*args, **kwargs)
+    app = app_utils.get_root_browser_app()
+    await app_utils.async_run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    parser = setup_parser()
+    args = parser.parse_args()
+    args_dict = vars(args)
+
+    if args_dict.get("generate_video_cover"):
+        from scripts.iib.video_cover_gen import generate_video_covers
+
+        conn = DataBase.get_conn()
+        generate_video_covers(
+            dirs = map(lambda x: x.path, ExtraPath.get_extra_paths(conn)),
+            verbose=args.gen_cache_verbose,
+        )
+        exit(0)
+    if args_dict.get("generate_image_cache"):
+        from scripts.iib.img_cache_gen import generate_image_cache
+        generate_image_cache(
+            dirs = get_all_img_dirs(args.sd_webui_config, args.sd_webui_path_relative_to_config), 
+            size = args.generate_image_cache_size,
+            verbose = args.gen_cache_verbose
+        )
+        exit(0)
+
+    launch_app(**vars(args))

extensions/sd-webui-infinite-image-browsing/install.py

@@ -0,0 +1,28 @@
+import launch
+import os
+import pkg_resources
+
+req_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "requirements.txt")
+
+def dist2package(dist: str):
+    return ({
+        "python-dotenv": "dotenv",
+        "Pillow": "PIL",
+        "pillow-avif-plugin": "pillow_avif"
+    }).get(dist, dist)
+
+# copy from controlnet, thanks
+with open(req_file) as file:
+    for package in file:
+        try:
+            package = package.strip()
+            if '==' in package:
+                package_name, package_version = package.split('==')
+                installed_version = pkg_resources.get_distribution(package_name).version
+                if installed_version != package_version:
+                    launch.run_pip(f"install {package}", f"sd-webui-infinite-image-browsing requirement: changing {package_name} version from {installed_version} to {package_version}")
+            elif not launch.is_installed(dist2package(package)):
+                launch.run_pip(f"install {package}", f"sd-webui-infinite-image-browsing requirement: {package}")
+        except Exception as e:
+            print(e)
+            print(f'Warning: Failed to install {package}, something may not work.')

extensions/sd-webui-infinite-image-browsing/javascript/index.js

@@ -0,0 +1,186 @@
+/* eslint-disable no-undef */
+Promise.resolve().then(async () => {
+  /**
+   * This is a file generated using `yarn build`.
+   * If you want to make changes, please modify `index.tpl.js` and run the command to generate it again.
+   */
+  const html = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate" />
+    <meta http-equiv="Expires" content="0" />
+    <meta charset="UTF-8" />
+    <link rel="icon" href="/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Infinite Image Browsing</title>
+    <script type="module" crossorigin src="/infinite_image_browsing/fe-static/assets/index-5b5fdd56.js"></script>
+    <link rel="stylesheet" href="/infinite_image_browsing/fe-static/assets/index-3112bec6.css">
+  </head>
+
+  <body>
+    <div id="zanllp_dev_gradio_fe">
+      It seems to have failed to load. You can try refreshing the page. <br> If that doesn't work, click on <a href="https://github.com/zanllp/sd-webui-infinite-image-browsing/issues/90" target="_blank" >FAQ</a> for help</div>
+    </div>
+    
+  </body>
+</html>
+`.replace(/\/infinite_image_browsing/g, (window.location.pathname + '/infinite_image_browsing').replace(/\/\//g, '/'))
+  let containerSelector = '#infinite_image_browsing_container_wrapper'
+  let shouldMaximize = localStorage.getItem('iib://disable_maximize') !== 'true'
+
+  try {
+    containerSelector = __iib_root_container__
+    shouldMaximize = __iib_should_maximize__
+  } catch (e) { /* empty */ }
+
+  const delay = (timeout = 0) => new Promise((resolve) => setTimeout(resolve, timeout))
+  const asyncCheck = async (getter, checkSize = 100, timeout = 1000) => {
+    let target = getter()
+    let num = 0
+    while (checkSize * num < timeout && (target === undefined || target === null)) {
+      await delay(checkSize)
+      target = getter()
+      num++
+    }
+    return target
+  }
+  
+  const getTabIdxById = (id) => {
+    const tabList = gradioApp().querySelectorAll('#tabs > .tabitem[id^=tab_]')
+    return Array.from(tabList).findIndex((v) => v.id.includes(id))
+  }
+
+  const switch2targetTab = (idx) => {
+    try {
+      gradioApp().querySelector('#tabs').querySelectorAll('button')[idx].click()
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  const isLobe = () => {
+    try {
+      return !!gradioApp().querySelector('[alt*="lobehub"]')
+    } catch (error) {
+      return false
+    }
+  }
+
+  /**
+   * @type {HTMLDivElement}
+   */
+  const wrap = await asyncCheck(() => gradioApp().querySelector(containerSelector), 500, Infinity)
+  wrap.childNodes.forEach((v) => wrap.removeChild(v))
+  const iframe = document.createElement('iframe')
+  iframe.srcdoc = html
+  iframe.style = 'width: 100%;height:100vh'
+  wrap.appendChild(iframe)
+
+  if (shouldMaximize) {
+    onUiTabChange(() => {
+      const el = get_uiCurrentTabContent()
+      if (el?.id.includes('infinite-image-browsing')) {
+        try {
+          const iibTop = gradioApp().querySelector('#iib_top')
+          if (!iibTop) {
+            throw new Error('element \'#iib_top\' is not found')
+          }
+          const topRect = iibTop.getBoundingClientRect()
+          wrap.style = `
+            top:${Math.max(isLobe() ? 32 : 128, topRect.top) - 10}px;
+            position: fixed;
+            left: 10px;
+            right: 10px;
+            z-index: 100;
+            width: unset;
+            bottom: 10px;`
+          iframe.style = 'width: 100%;height:100%'
+        } catch (error) {
+          console.error('Error mounting IIB. Running fallback.', error)
+          wrap.style = ''
+          iframe.style = 'width: 100%;height:100vh'
+        }
+      }
+    })
+  }
+
+  const IIB_container_id = [Date.now(), Math.random()].join()
+  window.IIB_container_id = IIB_container_id
+  const imgTransferBus = new BroadcastChannel('iib-image-transfer-bus')
+  imgTransferBus.addEventListener('message', async (ev) => {
+    const data = ev.data
+    if (
+      typeof data !== 'object' ||
+      (typeof data.IIB_container_id === 'string' && data.IIB_container_id !== IIB_container_id)
+    ) {
+      return
+    }
+    console.log('iib-message:', data)
+    const appDoc = gradioApp()
+    switch (data.event) {
+      case 'click_hidden_button': {
+        const btn = gradioApp().querySelector(`#${data.btnEleId}`)
+        btn.click()
+        break
+      }
+      case 'send_to_control_net': {
+        data.type === 'img2img' ? window.switch_to_img2img() : window.switch_to_txt2img()
+        await delay(100)
+        const cn = appDoc.querySelector(`#${data.type}_controlnet`)
+        const wrap = cn.querySelector('.label-wrap')
+        if (!wrap.className.includes('open')) {
+          wrap.click()
+          await delay(100)
+        }
+        wrap.scrollIntoView()
+        wrap.dispatchEvent(await createPasteEvent(data.url))
+        break
+      }
+      case 'send_to_outpaint': {
+        switch2targetTab(getTabIdxById('openOutpaint'))
+        await delay(100)
+        const iframe = appDoc.querySelector('#openoutpaint-iframe')
+        openoutpaint_send_image(await imgUrl2DataUrl(data.url))
+        iframe.contentWindow.postMessage({
+          key: appDoc.querySelector('#openoutpaint-key').value,
+          type: 'openoutpaint/set-prompt',
+          prompt: data.prompt,
+          negPrompt: data.negPrompt
+        })
+        break
+      }
+    }
+
+    function imgUrl2DataUrl(imgUrl) {
+      return new Promise((resolve, reject) => {
+        fetch(imgUrl)
+          .then((response) => response.blob())
+          .then((blob) => {
+            const reader = new FileReader()
+            reader.readAsDataURL(blob)
+            reader.onloadend = function () {
+              const dataURL = reader.result
+              resolve(dataURL)
+            }
+          })
+          .catch((error) => reject(error))
+      })
+    }
+
+    async function createPasteEvent(imgUrl) {
+      const response = await fetch(imgUrl)
+      const imageBlob = await response.blob()
+      const imageFile = new File([imageBlob], 'image.jpg', {
+        type: imageBlob.type,
+        lastModified: Date.now()
+      })
+      const dataTransfer = new DataTransfer()
+      dataTransfer.items.add(imageFile)
+      const pasteEvent = new ClipboardEvent('paste', {
+        clipboardData: dataTransfer,
+        bubbles: true
+      })
+      return pasteEvent
+    }
+  })
+})

extensions/sd-webui-infinite-image-browsing/migrate.py

@@ -0,0 +1,84 @@
+from contextlib import closing
+import argparse
+from scripts.iib.db.datamodel import DataBase
+import os
+
+import shutil
+
+
+def replace_path(old_base, new_base):
+    """
+    Custom SQL function to replace part of a path.
+
+    Args:
+        old_base (str): The base part of the path to be replaced.
+        new_base (str): The new base part of the path.
+
+    Returns:
+        str: Updated path.
+    """
+
+    def replace_func(path):
+        if path.startswith(old_base):
+            return new_base + path[len(old_base) :]
+        else:
+            return path
+
+    return replace_func
+
+
+def update_paths(conn, table_name, old_base):
+    """
+    Update paths in a specified SQLite table using a custom SQL function.
+
+    Args:
+        db_path (str): Path to the SQLite database file.
+        table_name (str): Name of the table containing the paths.
+
+    Returns:
+        None
+    """
+    with closing(conn.cursor()) as cur:
+        # Use the custom function in an UPDATE statement
+        cur.execute(
+            f"UPDATE {table_name} SET path = replace_path(path) WHERE path LIKE ?",
+            (f"{old_base}%",),
+        )
+
+        # Commit the changes and close the connection
+        conn.commit()
+
+
+def setup_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Script to migrate paths in an IIB SQLite database from an old directory structure to a new one."
+    )
+    parser.add_argument(
+        "--db_path", type=str, help="Path to the input IIB QLite database file to be migrated. Default value is 'iib.db'.", default="iib.db"
+    )
+    parser.add_argument(
+        "--old_dir", type=str, help="Old base directory to be replaced in the paths.", required=True
+    )
+    parser.add_argument(
+        "--new_dir", type=str, help="New base directory to replace the old base directory in the paths.", required=True
+    )
+    return parser
+
+
+if __name__ == "__main__":
+    parser = setup_parser()
+    args = parser.parse_args()
+    old_base = args.old_dir
+    new_base = args.new_dir
+    db_path = args.db_path
+    db_temp_path = "db_migrate_temp.db"
+    shutil.copy2(db_path, db_temp_path)
+    DataBase.path = os.path.normpath(os.path.join(os.getcwd(), db_temp_path))
+    conn = DataBase.get_conn()
+    conn.create_function("replace_path", 1, replace_path(old_base, new_base))
+    update_paths(conn, "image", old_base)
+    update_paths(conn, "extra_path", old_base)
+    update_paths(conn, "folders", old_base)
+    shutil.copy(db_temp_path, "iib.db")
+    # os.remove(db_temp_path)
+    print("Database migration completed successfully.")

extensions/sd-webui-infinite-image-browsing/requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+piexif
+python-dotenv
+Pillow
+pillow-avif-plugin
+imageio
+av
+lxml

extensions/sd-webui-infinite-image-browsing/scripts/iib/api.py

@@ -0,0 +1,1223 @@
+import base64
+from datetime import datetime, timedelta
+import io
+import os
+from pathlib import Path
+import shutil
+import sqlite3
+
+
+from scripts.iib.dir_cover_cache import get_top_4_media_info
+from scripts.iib.tool import (
+    get_created_date_by_stat,
+    get_video_type,
+    human_readable_size,
+    is_valid_media_path,
+    is_media_file,
+    get_cache_dir,
+    get_formatted_date,
+    is_win,
+    cwd,
+    locale,
+    enable_access_control,
+    get_windows_drives,
+    get_sd_webui_conf,
+    get_valid_img_dirs,
+    open_folder,
+    get_img_geninfo_txt_path,
+    unique_by,
+    create_zip_file,
+    normalize_paths,
+    to_abs_path,
+    is_secret_key_required,
+    open_file_with_default_app,
+    is_exe_ver,
+    backup_db_file,
+    get_current_commit_hash,
+    get_current_tag,
+    get_file_info_by_path,
+    get_data_file_path
+)
+from fastapi import FastAPI, HTTPException, Header, Response
+from fastapi.staticfiles import StaticFiles
+import asyncio
+from typing import List, Optional
+from pydantic import BaseModel
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+from PIL import Image
+from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+import hashlib
+from scripts.iib.db.datamodel import (
+    DataBase,
+    ExtraPathType,
+    Image as DbImg,
+    Tag,
+    Folder,
+    ImageTag,
+    ExtraPath,
+    FileInfoDict,
+    Cursor, 
+    GlobalSetting
+)
+from scripts.iib.db.update_image_data import update_image_data, rebuild_image_index, add_image_data_single
+from scripts.iib.logger import logger
+from scripts.iib.seq import seq
+import urllib.parse
+from scripts.iib.fastapi_video import range_requests_response, close_video_file_reader
+from scripts.iib.parsers.index import parse_image_info
+import scripts.iib.plugin
+
+try:
+    import pillow_avif
+except Exception as e:
+    logger.error(e)
+
+
+index_html_path = get_data_file_path("vue/dist/index.html") if is_exe_ver else os.path.join(cwd, "vue/dist/index.html")  # 在app.py也被使用
+
+
+send_img_path = {"value": ""}
+mem = {"secret_key_hash": None, "extra_paths": [], "all_scanned_paths": []}
+secret_key = os.getenv("IIB_SECRET_KEY")
+if secret_key:
+    print("Secret key loaded successfully. ")
+
+WRITEABLE_PERMISSIONS = ["read-write", "write-only"]
+
+is_api_writeable = not (os.getenv("IIB_ACCESS_CONTROL_PERMISSION")) or (
+    os.getenv("IIB_ACCESS_CONTROL_PERMISSION") in WRITEABLE_PERMISSIONS
+)
+IIB_DEBUG=False
+
+
+async def write_permission_required():
+    if not is_api_writeable:
+        error_msg = (
+            "User is not authorized to perform this action. Required permission: "
+            + ", ".join(WRITEABLE_PERMISSIONS)
+        )
+        raise HTTPException(status_code=403, detail=error_msg)
+
+
+async def verify_secret(request: Request):
+    if not secret_key:
+        if is_secret_key_required:
+            raise HTTPException(status_code=400, detail={"type": "secret_key_required"})
+        return
+    token = request.cookies.get("IIB_S")
+    if not token:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    if not mem["secret_key_hash"]:
+        mem["secret_key_hash"] = hashlib.sha256(
+            (secret_key + "_ciallo").encode("utf-8")
+        ).hexdigest()
+    if mem["secret_key_hash"] != token:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+
+DEFAULT_BASE = "/infinite_image_browsing"
+def infinite_image_browsing_api(app: FastAPI, **kwargs):
+    backup_db_file(DataBase.get_db_file_path())
+    api_base = kwargs.get("base") if isinstance(kwargs.get("base"), str) else DEFAULT_BASE
+    fe_public_path = kwargs.get("fe_public_path") if isinstance(kwargs.get("fe_public_path"), str) else api_base
+    cache_base_dir = get_cache_dir()
+
+    # print(f"IIB api_base:{api_base} fe_public_path:{fe_public_path}")
+    if IIB_DEBUG or is_exe_ver:
+        @app.exception_handler(Exception)
+        async def exception_handler(request: Request, exc: Exception):
+            error_msg = f"An exception occurred while processing {request.method} {request.url}: {exc}"
+            logger.error(error_msg)
+
+            return JSONResponse(
+                status_code=500, content={"message": "Internal Server Error"}
+            )
+        @app.middleware("http")
+        async def log_requests(request: Request, call_next):
+            path = request.url.path
+            if (
+                path.find("infinite_image_browsing/image-thumbnail") == -1
+                and path.find("infinite_image_browsing/file") == -1
+                and path.find("infinite_image_browsing/fe-static") == -1
+            ):
+                logger.info(f"Received request: {request.method} {request.url}")
+                if request.query_params:
+                    logger.debug(f"Query Params: {request.query_params}")
+                if request.path_params:
+                    logger.debug(f"Path Params: {request.path_params}")
+
+            try:
+                return await call_next(request)
+            except HTTPException as http_exc:
+                logger.warning(
+                    f"HTTPException occurred while processing {request.method} {request.url}: {http_exc}"
+                )
+                raise http_exc
+            except Exception as exc:
+                logger.error(
+                    f"An exception occurred while processing {request.method} {request.url}: {exc}"
+                )
+
+    
+    if kwargs.get("allow_cors"):
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origin_regex="^[\w./:-]+$",
+            allow_methods=["*"],
+            allow_headers=["*"],
+            allow_credentials=True,
+        )
+
+    def get_img_search_dirs():
+        try:
+            return get_valid_img_dirs(get_sd_webui_conf(**kwargs))
+        except Exception as e:
+            print(e)
+            return []
+
+    def update_all_scanned_paths():
+        allowed_paths = os.getenv("IIB_ACCESS_CONTROL_ALLOWED_PATHS")
+        if allowed_paths:
+            sd_webui_conf = get_sd_webui_conf(**kwargs)
+            path_config_key_map = {
+                "save": "outdir_save",
+                "extra": "outdir_extras_samples",
+                "txt2img": "outdir_txt2img_samples",
+                "img2img": "outdir_img2img_samples",
+            }
+
+            def path_map(path: str):
+                path = path.strip()
+                if path in path_config_key_map:
+                    return sd_webui_conf.get(path_config_key_map.get(path))
+                return path
+
+            paths = normalize_paths(
+                seq(allowed_paths.split(","))
+                .map(path_map)
+                .filter(lambda x: x)
+                .to_list(),
+                os.getcwd()
+            )
+        else:
+            paths = (
+                get_img_search_dirs()
+                + mem["extra_paths"]
+                + kwargs.get("extra_paths_cli", [])
+            )
+        mem["all_scanned_paths"] = unique_by(paths)
+
+    update_all_scanned_paths()
+
+    def update_extra_paths(conn: sqlite3.Connection):
+        r = ExtraPath.get_extra_paths(conn)
+        mem["extra_paths"] = [x.path for x in r]
+        update_all_scanned_paths()
+
+    def safe_commonpath(seq):
+        try:
+            return os.path.commonpath(seq)
+        except Exception as e:
+            # logger.error(e)
+            return ""
+
+    def is_path_under_parents(path, parent_paths: List[str] = []):
+        """
+        Check if the given path is under one of the specified parent paths.
+        :param path: The path to check.
+        :param parent_paths: By default, all scanned paths are included in the list of parent paths
+        :return: True if the path is under one of the parent paths, False otherwise.
+        """
+        try:
+            if not parent_paths:
+                parent_paths = mem["all_scanned_paths"]
+            path = to_abs_path(path)
+            for parent_path in parent_paths:
+                if safe_commonpath([path, parent_path]) == parent_path:
+                    return True
+        except Exception as e:
+            logger.error(e)
+        return False
+
+    def is_path_trusted(path: str):
+        if not enable_access_control:
+            return True
+        try:
+            parent_paths = mem["all_scanned_paths"]
+            path = to_abs_path(path)
+            for parent_path in parent_paths:
+                if len(path) <= len(parent_path):
+                    if parent_path.startswith(path):
+                        return True
+                else:
+                    if path.startswith(parent_path):
+                        return True
+        except:
+            pass
+        return False
+
+    def check_path_trust(path: str):
+        if not is_path_trusted(path):
+            raise HTTPException(status_code=403)
+
+    def filter_allowed_files(files: List[FileInfoDict]):
+        return [x for x in files if is_path_trusted(x["fullpath"])]
+
+
+
+    class PathsReq(BaseModel):
+        paths: List[str]
+
+    @app.get(f"{api_base}/hello")
+    async def greeting():
+        return "hello"
+
+    @app.get(f"{api_base}/global_setting", dependencies=[Depends(verify_secret)])
+    async def global_setting():
+        all_custom_tags = []
+
+        extra_paths = []
+        app_fe_setting = {}
+        try:
+            conn = DataBase.get_conn()
+            all_custom_tags = Tag.get_all_custom_tag(conn)
+            extra_paths = ExtraPath.get_extra_paths(conn) + [
+                ExtraPath(path, ExtraPathType.cli_only.value)
+                for path in kwargs.get("extra_paths_cli", [])
+            ]
+            update_extra_paths(conn)
+            app_fe_setting = GlobalSetting.get_all_settings(conn)
+        except Exception as e:
+            print(e)
+        return {
+            "global_setting": get_sd_webui_conf(**kwargs),
+            "cwd": cwd,
+            "is_win": is_win,
+            "home": os.environ.get("USERPROFILE") if is_win else os.environ.get("HOME"),
+            "sd_cwd": os.getcwd(),
+            "all_custom_tags": all_custom_tags,
+            "extra_paths": extra_paths,
+            "enable_access_control": enable_access_control,
+            "launch_mode": kwargs.get("launch_mode", "sd"),
+            "export_fe_fn": bool(kwargs.get("export_fe_fn")),
+            "app_fe_setting": app_fe_setting,
+            "is_readonly": not is_api_writeable,
+        }
+    
+    
+    class AppFeSettingReq(BaseModel):
+        name: str
+        value: str
+    
+    @app.post(f"{api_base}/app_fe_setting", dependencies=[Depends(verify_secret), Depends(write_permission_required)])
+    async def app_fe_setting(req: AppFeSettingReq):
+        conn = DataBase.get_conn()
+        GlobalSetting.save_setting(conn, req.name, req.value)
+
+    class AppFeSettingDelReq(BaseModel):
+        name: str
+
+    @app.delete(f"{api_base}/app_fe_setting", dependencies=[Depends(verify_secret), Depends(write_permission_required)])
+    async def remove_app_fe_setting(req: AppFeSettingDelReq):
+        conn = DataBase.get_conn()
+        GlobalSetting.remove_setting(conn, req.name)
+    
+    @app.get(f"{api_base}/version", dependencies=[Depends(verify_secret)])
+    async def get_version():
+        return {
+            "hash": get_current_commit_hash(),
+            "tag": get_current_tag(),
+        }
+
+    class DeleteFilesReq(BaseModel):
+        file_paths: List[str]
+
+    @app.post(
+        api_base + "/delete_files",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def delete_files(req: DeleteFilesReq):
+        conn = DataBase.get_conn()
+        for path in req.file_paths:
+            check_path_trust(path)
+            try:
+                if os.path.isdir(path):
+                    if len(os.listdir(path)):
+                        error_msg = (
+                            "When a folder is not empty, it is not allowed to be deleted."
+                            if locale == "en"
+                            else "文件夹不为空时不允许删除。"
+                        )
+                        raise HTTPException(400, detail=error_msg)
+                    shutil.rmtree(path)
+                else:
+                    close_video_file_reader(path)
+                    os.remove(path)
+                    txt_path = get_img_geninfo_txt_path(path)
+                    if txt_path:
+                        os.remove(txt_path)
+                    img = DbImg.get(conn, os.path.normpath(path))
+                    if img:
+                        logger.info("delete file: %s", path)
+                        ImageTag.remove(conn, img.id)
+                        DbImg.remove(conn, img.id)
+            except OSError as e:
+                # 处理删除失败的情况
+                logger.error("delete failed")
+                error_msg = (
+                    f"Error deleting file {path}: {e}"
+                    if locale == "en"
+                    else f"删除文件 {path} 时出错：{e}"
+                )
+                raise HTTPException(400, detail=error_msg)
+
+    class CreateFoldersReq(BaseModel):
+        dest_folder: str
+
+    @app.post(
+        api_base + "/mkdirs",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def create_folders(req: CreateFoldersReq):
+        if enable_access_control:
+            if not is_path_under_parents(req.dest_folder):
+                raise HTTPException(status_code=403)
+        os.makedirs(req.dest_folder, exist_ok=True)
+
+    class MoveFilesReq(BaseModel):
+        file_paths: List[str]
+        dest: str
+        create_dest_folder: Optional[bool] = False
+
+    @app.post(
+        api_base + "/copy_files",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def copy_files(req: MoveFilesReq):
+        for path in req.file_paths:
+            check_path_trust(path)
+            try:
+                shutil.copy(path, req.dest)
+                txt_path = get_img_geninfo_txt_path(path)
+                if txt_path:
+                    shutil.copy(txt_path, req.dest)
+            except OSError as e:
+                error_msg = (
+                    f"Error copying file {path} to {req.dest}: {e}"
+                    if locale == "en"
+                    else f"复制文件 {path} 到 {req.dest} 时出错：{e}"
+                )
+                raise HTTPException(400, detail=error_msg)
+
+    @app.post(
+        api_base + "/move_files",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def move_files(req: MoveFilesReq):
+        if req.create_dest_folder:
+            os.makedirs(req.dest, exist_ok=True)
+        elif not os.path.isdir(req.dest):
+            error_msg = (
+                f"Destination folder {req.dest} does not exist."
+                if locale == "en"
+                else f"目标文件夹 {req.dest} 不存在。"
+            )
+            raise HTTPException(400, detail=error_msg)
+
+        conn = DataBase.get_conn()        
+
+        def move_file_with_geninfo(path: str, dest: str):
+            path = os.path.normpath(path)
+            txt_path = get_img_geninfo_txt_path(path)
+            if txt_path:
+                shutil.move(txt_path, dest)
+            img = DbImg.get(conn, path)
+            new_path = os.path.normpath(os.path.join(dest, os.path.basename(path)))
+            if img:
+                logger.info(f"update file path: {path} -> {new_path} in db")
+                img.update_path(conn, new_path, force=True)
+
+        for path in req.file_paths:
+            check_path_trust(path)
+            path = os.path.normpath(path)
+            base_dir = os.path.dirname(path)
+            try:
+                files = list(os.walk(path))
+                is_dir = os.path.isdir(path)
+                shutil.move(path, req.dest)
+                if is_dir:
+                    for root, _, files in files:
+                        relative_path = root[len(base_dir) + 1 :]
+                        dest = os.path.join(req.dest, relative_path)
+                        for file in files:
+                            is_valid = is_media_file(file)
+                            if is_valid:
+                                move_file_with_geninfo(os.path.join(root, file), dest)
+                else:
+                    move_file_with_geninfo(path, req.dest)
+                            
+                conn.commit()
+            except OSError as e:
+                
+                conn.rollback()
+                error_msg = (
+                    f"Error moving file {path} to {req.dest}: {e}"
+                    if locale == "en"
+                    else f"移动文件 {path} 到 {req.dest} 时出错：{e}"
+                )
+                raise HTTPException(400, detail=error_msg)
+
+    @app.get(api_base + "/files", dependencies=[Depends(verify_secret)])
+    async def get_target_folder_files(folder_path: str):
+        files: List[FileInfoDict] = []
+        try:
+            if is_win and folder_path == "/":
+                for item in get_windows_drives():
+                    files.append(
+                        {"type": "dir", "size": "-", "name": item, "fullpath": item}
+                    )
+            else:
+                if not os.path.exists(folder_path):
+                    return {"files": []}
+                folder_path = to_abs_path(folder_path)
+                check_path_trust(folder_path)
+                folder_listing: List[os.DirEntry] = os.scandir(folder_path)
+                is_under_scanned_path = is_path_under_parents(folder_path)
+                for item in folder_listing:
+                    if not os.path.exists(item.path):
+                        continue
+                    fullpath = os.path.normpath(item.path)
+                    name = os.path.basename(item.path)
+                    stat = item.stat()
+                    date = get_formatted_date(stat.st_mtime)
+                    created_time = get_created_date_by_stat(stat)
+                    if item.is_file():
+                        bytes = stat.st_size
+                        size = human_readable_size(bytes)
+                        files.append(
+                            {
+                                "type": "file",
+                                "date": date,
+                                "size": size,
+                                "name": name,
+                                "bytes": bytes,
+                                "created_time": created_time,
+                                "fullpath": fullpath,
+                                "is_under_scanned_path": is_under_scanned_path,
+                            }
+                        )
+                    elif item.is_dir():
+                        files.append(
+                            {
+                                "type": "dir",
+                                "date": date,
+                                "created_time": created_time,
+                                "size": "-",
+                                "name": name,
+                                "is_under_scanned_path": is_under_scanned_path,
+                                "fullpath": fullpath,
+                            }
+                        )
+        except Exception as e:
+            # logger.error(e)
+            raise HTTPException(status_code=400, detail=str(e))
+
+        return {"files": filter_allowed_files(files)}
+    
+
+    @app.post(api_base + "/batch_get_files_info", dependencies=[Depends(verify_secret)])
+    async def batch_get_files_info(req: PathsReq):
+        res = {}
+        for path in req.paths:
+            check_path_trust(path)
+            res[path] = get_file_info_by_path(path)
+        return res
+
+    @app.get(api_base + "/image-thumbnail", dependencies=[Depends(verify_secret)])
+    async def thumbnail(path: str, t: str, size: str = "256x256"):
+        check_path_trust(path)
+        if not cache_base_dir:
+            return
+        # 生成缓存文件的路径
+        hash_dir = hashlib.md5((path + t).encode("utf-8")).hexdigest()
+        hash = hash_dir + size
+        cache_dir = os.path.join(cache_base_dir, "iib_cache", hash_dir)
+        cache_path = os.path.join(cache_dir, f"{size}.webp")
+
+        # 如果缓存文件存在，则直接返回该文件
+        if os.path.exists(cache_path):
+            return FileResponse(
+                cache_path,
+                media_type="image/webp",
+                headers={"Cache-Control": "max-age=31536000", "ETag": hash},
+            )
+
+                
+        # 如果小于64KB，直接返回原图
+        if os.path.getsize(path) < 64 * 1024:
+            return FileResponse(
+                path,
+                media_type="image/" + path.split(".")[-1],
+                headers={"Cache-Control": "max-age=31536000", "ETag": hash},
+            )
+        
+
+        # 如果缓存文件不存在，则生成缩略图并保存
+        with Image.open(path) as img:
+            w, h = size.split("x")
+            img.thumbnail((int(w), int(h)))
+            os.makedirs(cache_dir, exist_ok=True)
+            img.save(cache_path, "webp")
+
+        # 返回缓存文件
+        return FileResponse(
+            cache_path,
+            media_type="image/webp",
+            headers={"Cache-Control": "max-age=31536000", "ETag": hash},
+        )
+
+    @app.get(api_base + "/file", dependencies=[Depends(verify_secret)])
+    async def get_file(path: str, t: str, disposition: Optional[str] = None):
+        filename = path
+        import mimetypes
+
+        check_path_trust(path)
+        if not os.path.exists(filename):
+            raise HTTPException(status_code=404)
+        if not os.path.isfile(filename):
+            raise HTTPException(status_code=400, detail=f"{filename} is not a file")
+        # 根据文件后缀名获取媒体类型
+        media_type, _ = mimetypes.guess_type(filename)
+        headers = {}
+        if disposition:
+            encoded_filename = urllib.parse.quote(disposition.encode('utf-8'))
+            headers['Content-Disposition'] = f"attachment; filename*=UTF-8''{encoded_filename}"
+
+        if is_path_under_parents(filename) and is_valid_media_path(
+            filename
+        ):  # 认为永远不变,不要协商缓存了试试
+            headers[
+                "Cache-Control"
+            ] = "public, max-age=31536000"  # 针对同样名字文件但实际上不同内容的文件要求必须传入创建时间来避免浏览器缓存
+            headers["Expires"] = (datetime.now() + timedelta(days=365)).strftime(
+                "%a, %d %b %Y %H:%M:%S GMT"
+            )
+
+        return FileResponse(
+            filename,
+            media_type=media_type,
+            headers=headers,
+        )
+    
+    @app.get(api_base + "/stream_video", dependencies=[Depends(verify_secret)])
+    async def stream_video(path: str, request: Request):      
+        check_path_trust(path)
+        import mimetypes
+        media_type, _ = mimetypes.guess_type(path)
+        return range_requests_response(
+            request, file_path=path, content_type=media_type
+        )
+
+    @app.get(api_base + "/video_cover", dependencies=[Depends(verify_secret)])
+    async def video_cover(path: str, mt: str):        
+        check_path_trust(path)
+        if not cache_base_dir:
+            return
+        
+        if not os.path.exists(path):
+            raise HTTPException(status_code=404)
+        if not os.path.isfile(path) and get_video_type(path):
+            raise HTTPException(status_code=400, detail=f"{path} is not a video file")
+        # 生成缓存文件的路径
+        hash_dir = hashlib.md5((path + mt).encode("utf-8")).hexdigest()
+        hash = hash_dir
+        cache_dir = os.path.join(cache_base_dir, "iib_cache", "video_cover", hash_dir)
+        cache_path = os.path.join(cache_dir, "cover.webp")
+        # 如果缓存文件存在，则直接返回该文件
+        if os.path.exists(cache_path):
+            return FileResponse(
+                cache_path,
+                media_type="image/webp",
+                headers={
+                    "Cache-Control": "no-store",
+                },
+            )
+        # 如果缓存文件不存在，则生成缩略图并保存
+        
+        import imageio.v3 as iio
+        frame = iio.imread(
+            path,
+            index=16,
+            plugin="pyav",
+        )
+        
+        os.makedirs(cache_dir, exist_ok=True)
+        iio.imwrite(cache_path,frame, extension=".webp")
+
+        # 返回缓存文件
+        return FileResponse(
+            cache_path,
+            media_type="image/webp",
+            headers={
+                "Cache-Control": "no-store",
+            },
+        )
+    
+    class SetTargetFrameAsCoverReq(BaseModel):
+        base64_img: str
+        path: str
+        updated_time: str
+
+    def save_base64_image(base64_str, file_path):
+        if base64_str.startswith('data:image'):
+            base64_str = base64_str.split(',')[1]
+        image_data = base64.b64decode(base64_str)
+        with open(file_path, 'wb') as file:
+            file.write(image_data)
+
+    @app.post(api_base+ "/set_target_frame_as_video_cover", dependencies=[Depends(verify_secret), Depends(write_permission_required)])
+    async def set_target_frame_as_video_cover(req: SetTargetFrameAsCoverReq):
+        hash_dir = hashlib.md5((req.path + req.updated_time).encode("utf-8")).hexdigest()
+        hash = hash_dir
+        cache_dir = os.path.join(cache_base_dir, "iib_cache", "video_cover", hash_dir)
+        cache_path = os.path.join(cache_dir, "cover.webp")
+
+        os.makedirs(cache_dir, exist_ok=True)
+        
+        save_base64_image(req.base64_img, cache_path)
+        return FileResponse(
+            cache_path,
+            media_type="image/webp",
+            headers={"ETag": hash},
+        )
+
+    @app.post(api_base + "/send_img_path", dependencies=[Depends(verify_secret)])
+    async def api_set_send_img_path(path: str):
+        send_img_path["value"] = path
+
+    # 等待图片信息生成完成
+    @app.get(api_base + "/gen_info_completed", dependencies=[Depends(verify_secret)])
+    async def api_set_send_img_path():
+        for _ in range(30):  # timeout 3s
+            if send_img_path["value"] == "":  # 等待setup里面生成完成
+                return True
+            v = send_img_path["value"]
+            # is_dev and logger.info("gen_info_completed %s %s", _, v)
+            await asyncio.sleep(0.1)
+        return send_img_path["value"] == ""
+
+    @app.get(api_base + "/image_geninfo", dependencies=[Depends(verify_secret)])
+    async def image_geninfo(path: str):
+        return parse_image_info(path).raw_info
+
+    class GeninfoBatchReq(BaseModel):
+        paths: List[str]
+
+    @app.post(api_base + "/image_geninfo_batch", dependencies=[Depends(verify_secret)])
+    async def image_geninfo_batch(req: GeninfoBatchReq):
+        res = {}
+        conn = DataBase.get_conn()
+        for path in req.paths:
+            try:
+                img = DbImg.get(conn, path)
+                if img:
+                    res[path] = img.exif
+                else:
+                    res[path] = parse_image_info(path).raw_info
+            except Exception as e:
+                logger.error(e, stack_info=True)
+        return res
+
+
+    class CheckPathExistsReq(BaseModel):
+        paths: List[str]
+
+    @app.post(api_base + "/check_path_exists", dependencies=[Depends(verify_secret)])
+    async def check_path_exists(req: CheckPathExistsReq):
+        update_all_scanned_paths()
+        res = {}
+        for path in req.paths:
+            res[path] = os.path.exists(path) and is_path_trusted(path)
+        return res
+
+    @app.get(api_base)
+    def index_bd():
+        if fe_public_path:
+            with open(index_html_path, "r", encoding="utf-8") as file:
+                content = file.read().replace(DEFAULT_BASE, fe_public_path)
+                return Response(content=content, media_type="text/html")
+        return FileResponse(index_html_path)
+    
+    static_dir = get_data_file_path("vue/dist") if is_exe_ver else f"{cwd}/vue/dist" 
+    @app.get(api_base + "/fe-static/{file_path:path}")
+    async def serve_static_file(file_path: str):
+        file_full_path = f"{static_dir}/{file_path}"
+        if file_path.endswith(".js"):
+            with open(file_full_path, "r", encoding="utf-8") as file:
+                content = file.read().replace(DEFAULT_BASE, fe_public_path)
+            return Response(content=content, media_type="text/javascript")
+        else:
+            return FileResponse(file_full_path)
+
+    class OpenFolderReq(BaseModel):
+        path: str
+
+    @app.post(
+        api_base + "/open_folder",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    def open_folder_using_explore(req: OpenFolderReq):
+        if not is_path_trusted(req.path):
+            raise HTTPException(status_code=403)
+        open_folder(*os.path.split(req.path))
+
+    @app.post(api_base + "/shutdown")
+    async def shutdown_app():
+        # This API endpoint is mainly used as a sidecar in Tauri applications to shut down the application
+        if not kwargs.get("enable_shutdown"):
+            raise HTTPException(status_code=403, detail="Shutdown is disabled.")
+        os.kill(os.getpid(), 9)
+        return {"message": "Application is shutting down."}
+
+
+    class PackReq(BaseModel):
+        paths: List[str]
+        compress: bool
+        pack_only: bool
+
+
+    @app.post(
+        api_base + "/zip",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    def zip_files(req: PackReq):
+        for path in req.paths:
+            check_path_trust(path)
+            if not os.path.isfile(path):
+                   raise HTTPException(400, "The corresponding path must be a file.")
+        now = datetime.now()
+        timestamp = now.strftime("%Y-%m-%d-%H-%M-%S")
+        zip_temp_dir = os.path.join(cwd, "zip_temp")
+        os.makedirs(zip_temp_dir, exist_ok=True)
+        file_path = os.path.join(zip_temp_dir, f"iib_batch_download_{timestamp}.zip")
+        create_zip_file(req.paths, file_path, req.compress)
+        if not req.pack_only:
+            return FileResponse(file_path, media_type="application/zip")
+    
+    @app.post(
+        api_base + "/open_with_default_app",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    def open_target_file_withDefault_app(req: OpenFolderReq):
+        check_path_trust(req.path)
+        open_file_with_default_app(req.path)
+
+
+    @app.post(
+        api_base + "/batch_top_4_media_info",
+        dependencies=[Depends(verify_secret)],
+    )
+    def batch_get_top_4_media_cover_info(req: PathsReq):
+        for path in req.paths:
+            check_path_trust(path)
+        res = {}
+        for path in req.paths:
+            res[path] = get_top_4_media_info(path)
+        return res
+
+    db_api_base = api_base + "/db"
+
+    @app.get(db_api_base + "/basic_info", dependencies=[Depends(verify_secret)])
+    async def get_db_basic_info():
+        conn = DataBase.get_conn()
+        img_count = DbImg.count(conn)
+        tags = Tag.get_all(conn)
+        expired_dirs = Folder.get_expired_dirs(conn)
+        return {
+            "img_count": img_count,
+            "tags": tags,
+            "expired": len(expired_dirs) != 0,
+            "expired_dirs": expired_dirs,
+        }
+    
+    
+    
+
+    @app.get(db_api_base + "/random_images", dependencies=[Depends(verify_secret)])
+    async def random_image():
+        conn = DataBase.get_conn()
+        imgs = DbImg.get_random_images(conn, 128)
+        return filter_allowed_files([x.to_file_info() for x in imgs])
+
+    @app.get(db_api_base + "/expired_dirs", dependencies=[Depends(verify_secret)])
+    async def get_db_expired():
+        conn = DataBase.get_conn()
+        expired_dirs = Folder.get_expired_dirs(conn)
+        return {
+            "expired": len(expired_dirs) != 0,
+            "expired_dirs": expired_dirs,
+        }
+
+    @app.post(
+        db_api_base + "/update_image_data",
+        dependencies=[Depends(verify_secret)],
+    )
+    async def update_image_db_data():
+        try:
+            DataBase._initing = True
+            conn = DataBase.get_conn()
+            img_count = DbImg.count(conn)
+            update_extra_paths(conn)
+            dirs = (
+                get_img_search_dirs()
+                if img_count == 0
+                else Folder.get_expired_dirs(conn)
+            ) + mem["extra_paths"]
+
+            update_image_data(dirs)
+        finally:
+            DataBase._initing = False
+
+    class SearchBySubstrReq(BaseModel):
+        surstr: str
+        cursor: str
+        regexp: str
+        folder_paths: List[str] = None
+        size: Optional[int] = 200
+        path_only: Optional[bool] = False
+
+    @app.post(db_api_base + "/search_by_substr", dependencies=[Depends(verify_secret)])
+    async def search_by_substr(req: SearchBySubstrReq):
+        if IIB_DEBUG:
+            logger.info(req)
+        conn = DataBase.get_conn()
+        folder_paths=normalize_paths(req.folder_paths, os.getcwd())
+        if(not folder_paths and req.folder_paths):
+            return { "files": [], "cursor": Cursor(has_next=False) }
+        imgs, next_cursor = DbImg.find_by_substring(
+            conn=conn, 
+            substring=req.surstr, 
+            cursor=req.cursor, 
+            limit=req.size,
+            regexp=req.regexp,
+            folder_paths=folder_paths,
+            path_only=req.path_only
+        )
+        return {
+            "files": filter_allowed_files([x.to_file_info() for x in imgs]),
+            "cursor": next_cursor
+        }
+    
+    class MatchImagesByTagsReq(BaseModel):
+        and_tags: List[int]
+        or_tags: List[int]
+        not_tags: List[int]
+        cursor: str
+        folder_paths: List[str] = None
+        size: Optional[int] = 200
+
+    @app.post(db_api_base + "/match_images_by_tags", dependencies=[Depends(verify_secret)])
+    async def match_image_by_tags(req: MatchImagesByTagsReq):
+        if IIB_DEBUG:
+            logger.info(req)
+        conn = DataBase.get_conn()
+        folder_paths=normalize_paths(req.folder_paths, os.getcwd())
+        if(not folder_paths and req.folder_paths):
+            return { "files": [], "cursor": Cursor(has_next=False) }
+        imgs, next_cursor = ImageTag.get_images_by_tags(
+            conn=conn,
+            tag_dict={"and": req.and_tags, "or": req.or_tags, "not": req.not_tags},
+            cursor=req.cursor,
+            folder_paths=folder_paths,
+            limit=req.size
+        )
+        return {
+            "files": filter_allowed_files([x.to_file_info() for x in imgs]),
+            "cursor": next_cursor
+        }
+
+    @app.get(db_api_base + "/img_selected_custom_tag", dependencies=[Depends(verify_secret)])
+    async def get_img_selected_custom_tag(path: str):
+        path = os.path.normpath(path)
+        if not is_valid_media_path(path):
+            return []
+        conn = DataBase.get_conn()
+        update_extra_paths(conn)
+        if not is_path_under_parents(path):
+            return []
+        img = DbImg.get(conn, path)
+        if not img:
+            if DbImg.count(conn) == 0:
+                return []
+            update_image_data([os.path.dirname(path)])
+            img = DbImg.get(conn, path)
+        assert img
+        # tags = Tag.get_all_custom_tag()
+        return ImageTag.get_tags_for_image(conn, img.id, type="custom")
+
+    @app.post(db_api_base + "/get_image_tags", dependencies=[Depends(verify_secret)])
+    async def get_img_tags(req: PathsReq):
+        conn = DataBase.get_conn()
+        return ImageTag.batch_get_tags_by_path(conn, req.paths)
+    
+
+    # update tag
+    class UpdateTagReq(BaseModel):
+        id: int
+        color: str
+
+    @app.post(
+        db_api_base + "/update_tag",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def update_tag(req: UpdateTagReq):
+        conn = DataBase.get_conn()
+        tag = Tag.get(conn, req.id)
+        if tag:
+            tag.color = req.color
+            tag.save(conn)
+        conn.commit()
+
+
+    class ToggleCustomTagToImgReq(BaseModel):
+        img_path: str
+        tag_id: int
+
+    @app.post(
+        db_api_base + "/toggle_custom_tag_to_img",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def toggle_custom_tag_to_img(req: ToggleCustomTagToImgReq):
+        conn = DataBase.get_conn()
+        path = os.path.normpath(req.img_path)
+        update_extra_paths(conn)
+        if not is_path_under_parents(path):
+            raise HTTPException(
+                400,
+                '当前文件不在搜索路径内，你可以将它添加到扫描路径再尝试。在右上角的"更多"里面'
+                if locale == "zh"
+                else 'The current file is not within the scan path. You can add it to the scan path and try again. In the top right corner, click on "More".',
+            )
+        img = DbImg.get(conn, path)
+        if not img:
+            if DbImg.count(conn):
+                # update_image_data([os.path.dirname(path)])
+                add_image_data_single(path)
+                img = DbImg.get(conn, path)
+            else:
+                raise HTTPException(
+                    400,
+                    "你需要先通过图像搜索页生成索引"
+                    if locale == "zh"
+                    else "You need to generate an index through the image search page first.",
+                )
+        tags = ImageTag.get_tags_for_image(
+            conn=conn, image_id=img.id, type="custom", tag_id=req.tag_id
+        )
+        is_remove = len(tags)
+        if is_remove:
+            ImageTag.remove(conn, img.id, tags[0].id)
+        else:
+            ImageTag(img.id, req.tag_id).save(conn)
+        conn.commit()
+        return {"is_remove": is_remove}
+
+    class BatchUpdateImageReq(BaseModel):
+        img_paths: List[str]
+        action: str
+        tag_id: int
+
+    @app.post(
+        db_api_base + "/batch_update_image_tag",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def batch_update_image_tag(req: BatchUpdateImageReq):
+        assert req.action in ["add", "remove"]
+        conn = DataBase.get_conn()
+        paths: List[str] = seq(req.img_paths).map(os.path.normpath).to_list()
+        update_extra_paths(conn)
+        for path in paths:
+            if not is_path_under_parents(path):
+                raise HTTPException(
+                    400,
+                    '当前文件不在搜索路径内，你可以将它添加到扫描路径再尝试。在右上角的"更多"里面'
+                    if locale == "zh"
+                    else 'The current file is not within the scan path. You can add it to the scan path and try again. In the top right corner, click on "More".',
+                )
+            img = DbImg.get(conn, path)
+            if not img:
+                if DbImg.count(conn):
+                    add_image_data_single(path)
+                    img = DbImg.get(conn, path)
+                else: 
+                    raise HTTPException(
+                        400,
+                        "你需要先通过图像搜索页生成索引"
+                        if locale == "zh"
+                        else "You need to generate an index through the image search page first.",
+                    )
+        try:            
+            for path in paths:
+                img = DbImg.get(conn, path)
+                if req.action == "add":
+                    ImageTag(img.id, req.tag_id).save_or_ignore(conn)
+                else:
+                    ImageTag.remove(conn, img.id, req.tag_id)
+        finally:
+            conn.commit()
+
+    class AddCustomTagReq(BaseModel):
+        tag_name: str
+
+    @app.post(
+        db_api_base + "/add_custom_tag",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def add_custom_tag(req: AddCustomTagReq):
+        conn = DataBase.get_conn()
+        tag = Tag.get_or_create(conn, name=req.tag_name, type="custom")
+        conn.commit()
+        return tag
+    
+    class RenameFileReq(BaseModel):
+        path: str
+        name: str
+
+    @app.post(
+        db_api_base + "/rename",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def rename_file(req: RenameFileReq):
+        conn = DataBase.get_conn()
+        try:
+            # Normalize the paths
+
+            path = os.path.normpath(req.path)
+            new_path = os.path.join(os.path.dirname(path), req.name)
+
+            # Check if the file exists
+            if not os.path.exists(path):
+                raise HTTPException(status_code=404, detail="File not found")
+
+            # Check if a file with the new name already exists
+            if os.path.exists(new_path):
+                raise HTTPException(status_code=400, detail="A file with the new name already exists")
+            close_video_file_reader(path)
+            img = DbImg.get(conn, path)
+            if img:
+                img.update_path(conn, new_path)
+                conn.commit()
+
+            # Perform the file rename operation
+            os.rename(path, new_path)
+
+
+            return {"detail": "File renamed successfully", "new_path": new_path}
+
+        except PermissionError:
+            raise HTTPException(status_code=403, detail="Permission denied")
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    class RemoveCustomTagReq(BaseModel):
+        tag_id: int
+
+    @app.post(
+        db_api_base + "/remove_custom_tag",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def remove_custom_tag(req: RemoveCustomTagReq):
+        conn = DataBase.get_conn()
+        ImageTag.remove(conn, tag_id=req.tag_id)
+        Tag.remove(conn, req.tag_id)
+
+    class RemoveCustomTagFromReq(BaseModel):
+        img_id: int
+        tag_id: str
+
+    @app.post(
+        db_api_base + "/remove_custom_tag_from_img",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def remove_custom_tag_from_img(req: RemoveCustomTagFromReq):
+        conn = DataBase.get_conn()
+        ImageTag.remove(conn, image_id=req.img_id, tag_id=req.tag_id)
+
+
+
+
+    class ExtraPathModel(BaseModel):
+        path: str
+        types: List[str]
+
+    @app.post(
+        f"{db_api_base}/extra_paths",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def create_extra_path(extra_path: ExtraPathModel):
+        if enable_access_control:
+            if not is_path_under_parents(extra_path.path):
+                raise HTTPException(status_code=403)
+        conn = DataBase.get_conn()
+        path = ExtraPath.get_target_path(conn, extra_path.path)
+        if path:
+            for t in extra_path.types:
+                path.types.append(t)
+            path.types = unique_by(path.types)
+        else:
+            path = ExtraPath(extra_path.path, extra_path.types)
+        try:
+            path.save(conn)
+        finally:
+            conn.commit()
+
+    class ExtraPathAliasModel(BaseModel):
+        path: str
+        alias: str
+
+
+    @app.post(
+        f"{db_api_base}/alias_extra_path",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def alias_extra_path(req: ExtraPathAliasModel):
+        conn = DataBase.get_conn()
+        path = ExtraPath.get_target_path(conn, req.path)
+        if not path:
+            raise HTTPException(400)
+        path.alias = req.alias
+        try:
+            path.save(conn)
+        finally:
+            conn.commit()
+        return path
+        
+
+    @app.get(
+        f"{db_api_base}/extra_paths",
+        dependencies=[Depends(verify_secret)],
+    )
+    async def read_extra_paths():
+        conn = DataBase.get_conn()
+        return ExtraPath.get_extra_paths(conn)
+    
+
+
+    @app.delete(
+        f"{db_api_base}/extra_paths",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def delete_extra_path(extra_path: ExtraPathModel):
+        path = to_abs_path(extra_path.path)
+        conn = DataBase.get_conn()
+        ExtraPath.remove(conn, path, extra_path.types, img_search_dirs=get_img_search_dirs())
+
+    
+    @app.post(
+        f"{db_api_base}/rebuild_index",
+        dependencies=[Depends(verify_secret), Depends(write_permission_required)],
+    )
+    async def rebuild_index():
+        update_extra_paths(conn = DataBase.get_conn())
+        rebuild_image_index(search_dirs = get_img_search_dirs() + mem["extra_paths"])
+

extensions/sd-webui-infinite-image-browsing/scripts/iib/db/datamodel.py

@@ -0,0 +1,890 @@
+from datetime import datetime
+import json
+import random
+from sqlite3 import Connection, connect
+from enum import Enum
+import sqlite3
+from typing import Dict, List, Optional, TypedDict, Union
+from scripts.iib.tool import (
+    cwd,
+    get_modified_date,
+    human_readable_size,
+    tags_translate,
+    is_dev,
+    find,
+    unique_by,
+)
+from contextlib import closing
+import os
+import threading
+import re
+
+
+class FileInfoDict(TypedDict):
+    type: str
+    date: float
+    size: int
+    name: str
+    bytes: bytes
+    created_time: float
+    fullpath: str
+
+
+class Cursor:
+    def __init__(self, has_next=True, next=""):
+        self.has_next = has_next
+        self.next = next
+
+
+class DataBase:
+    local = threading.local()
+
+    _initing = False
+
+    num = 0
+
+    path = os.getenv("IIB_DB_PATH", "iib.db")
+
+    @classmethod
+    def get_conn(clz) -> Connection:
+        # for : sqlite3.ProgrammingError: SQLite objects created in a thread can only be used in that same thread
+        if hasattr(clz.local, "conn"):
+            return clz.local.conn
+        else:
+            conn = clz.init()
+            clz.local.conn = conn
+
+            return conn
+        
+    @classmethod
+    def get_db_file_path(clz):
+        return clz.path if os.path.isabs(clz.path) else os.path.join(cwd, clz.path)
+
+    @classmethod
+    def init(clz):
+        # 创建连接并打开数据库
+        conn = connect(clz.get_db_file_path())
+
+        def regexp(expr, item):
+            if not isinstance(item, str):
+                return False
+            reg = re.compile(expr, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL)
+            return reg.search(item) is not None
+
+        conn.create_function("regexp", 2, regexp)
+        try:
+            Folder.create_table(conn)
+            ImageTag.create_table(conn)
+            Tag.create_table(conn)
+            Image.create_table(conn)
+            ExtraPath.create_table(conn)
+            DirCoverCache.create_table(conn)
+            GlobalSetting.create_table(conn)
+        finally:
+            conn.commit()
+        clz.num += 1
+        if is_dev:
+            print(f"当前连接数{clz.num}")
+        return conn
+
+
+class Image:
+    def __init__(self, path, exif=None, size=0, date="", id=None):
+        self.path = path
+        self.exif = exif
+        self.id = id
+        self.size = size
+        self.date = date
+
+    def to_file_info(self) -> FileInfoDict:
+        return {
+            "type": "file",
+            "id": self.id,
+            "date": self.date,
+            "created_date": self.date,
+            "size": human_readable_size(self.size),
+            "is_under_scanned_path": True,
+            "bytes": self.size,
+            "name": os.path.basename(self.path),
+            "fullpath": self.path,
+        }
+
+    def save(self, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "INSERT OR REPLACE  INTO image (path, exif, size, date) VALUES (?, ?, ?, ?)",
+                (self.path, self.exif, self.size, self.date),
+            )
+            self.id = cur.lastrowid
+
+    def update_path(self, conn: Connection, new_path: str, force=False):
+        self.path = os.path.normpath(new_path)
+        with closing(conn.cursor()) as cur:
+            if force: # force update path
+                cur.execute("DELETE FROM image WHERE path = ?", (self.path,))
+            cur.execute("UPDATE image SET path = ? WHERE id = ?", (self.path, self.id))
+
+    @classmethod
+    def get(cls, conn: Connection, id_or_path):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "SELECT * FROM image WHERE id = ? OR path = ?", (id_or_path, id_or_path)
+            )
+            row = cur.fetchone()
+            if row is None:
+                return None
+            else:
+                return cls.from_row(row)
+
+    @classmethod
+    def get_by_ids(cls, conn: Connection, ids: List[int]) -> List["Image"]:
+        if not ids:
+            return []
+
+        query = """
+            SELECT * FROM image
+            WHERE id IN ({})
+        """.format(
+            ",".join("?" * len(ids))
+        )
+
+        with closing(conn.cursor()) as cur:
+            cur.execute(query, ids)
+            rows = cur.fetchall()
+
+        images = []
+        for row in rows:
+            images.append(cls.from_row(row))
+        return images
+
+    @classmethod
+    def create_table(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                """CREATE TABLE IF NOT EXISTS image (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            path TEXT UNIQUE,
+                            exif TEXT,
+                            size INTEGER,
+                            date TEXT
+                        )"""
+            )
+            cur.execute("CREATE INDEX IF NOT EXISTS image_idx_path ON image(path)")
+
+    @classmethod
+    def count(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT COUNT(*) FROM image")
+            count = cur.fetchone()[0]
+            return count
+
+    @classmethod
+    def from_row(cls, row: tuple):
+        image = cls(path=row[1], exif=row[2], size=row[3], date=row[4])
+        image.id = row[0]
+        return image
+
+    @classmethod
+    def remove(cls, conn: Connection, image_id: int) -> None:
+        with closing(conn.cursor()) as cur:
+            cur.execute("DELETE FROM image WHERE id = ?", (image_id,))
+            conn.commit()
+
+    @classmethod
+    def safe_batch_remove(cls, conn: Connection, image_ids: List[int]) -> None:
+        if not (image_ids):
+            return
+        with closing(conn.cursor()) as cur:
+            try:
+                placeholders = ",".join("?" * len(image_ids))
+                cur.execute(
+                    f"DELETE FROM image_tag WHERE image_id IN ({placeholders})",
+                    image_ids,
+                )
+                cur.execute(
+                    f"DELETE FROM image WHERE id IN ({placeholders})", image_ids
+                )
+            except BaseException as e:
+                print(e)
+            finally:
+                conn.commit()
+
+    @classmethod
+    def find_by_substring(
+        cls, conn: Connection, substring: str, limit: int = 500, cursor="", regexp="", path_only=False,
+        folder_paths: List[str] = []
+    ) -> tuple[List["Image"], Cursor]:
+        api_cur = Cursor()
+        with closing(conn.cursor()) as cur:
+            params = []
+            where_clauses = []
+            if regexp:
+                if path_only:
+                    where_clauses.append("(path REGEXP ?)")
+                    params.append(regexp)
+                else:
+                    where_clauses.append("((exif REGEXP ?) OR (path REGEXP ?))")
+                    params.extend((regexp, regexp))
+            else:
+                if path_only:
+                    where_clauses.append("(path LIKE ?)")
+                    params.append(f"%{substring}%")
+                else:
+                    where_clauses.append("(path LIKE ? OR exif LIKE ?)")
+                    params.extend((f"%{substring}%", f"%{substring}%"))
+            if cursor:
+                where_clauses.append("(date < ?)")
+                params.append(cursor)
+            if folder_paths:
+                folder_clauses = []
+                for folder_path in folder_paths:
+                    folder_clauses.append("(image.path LIKE ?)")
+                    params.append(os.path.join(folder_path, "%"))
+                where_clauses.append("(" + " OR ".join(folder_clauses) + ")")
+            sql = "SELECT * FROM image"
+            if where_clauses:
+                sql += " WHERE "
+                sql += " AND ".join(where_clauses)
+            sql += " ORDER BY date DESC LIMIT ? "
+            params.append(limit)
+            cur.execute(sql, params)
+            rows = cur.fetchall()
+
+        api_cur.has_next = len(rows) >= limit
+        images = []
+        deleted_ids = []
+        for row in rows:
+            img = cls.from_row(row)
+            if os.path.exists(img.path):
+                images.append(img)
+            else:
+                deleted_ids.append(img.id)
+        cls.safe_batch_remove(conn, deleted_ids)
+        if images:
+            api_cur.next = str(images[-1].date)
+        return images, api_cur
+    
+    @classmethod
+    def get_random_images(cls, conn: Connection, size: int) -> List["Image"]:
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT COUNT(*) FROM image")
+            total_count = cur.fetchone()[0]
+
+            if total_count == 0 or size <= 0:
+                return []
+
+            step = max(1, total_count // size)
+
+            start_indices = [random.randint(i * step, min((i + 1) * step - 1, total_count - 1)) for i in range(size)]
+
+            placeholders = ",".join("?" * len(start_indices))
+            cur.execute(f"SELECT * FROM image WHERE id IN ({placeholders})", start_indices)
+            rows = cur.fetchall()
+
+        images = [cls.from_row(row) for row in rows if os.path.exists(row[1])]
+        return images
+
+
+class Tag:
+    def __init__(self, name: str, score: int, type: str, count=0, color = ""):
+        self.name = name
+        self.score = score
+        self.type = type
+        self.count = count
+        self.id = None
+        self.color = color
+        self.display_name = tags_translate.get(name)
+
+    def save(self, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "INSERT OR REPLACE INTO tag (id, name, score, type, count, color) VALUES (?, ?, ?, ?, ?, ?)",
+                (self.id, self.name, self.score, self.type, self.count, self.color),
+            )
+            self.id = cur.lastrowid
+
+    @classmethod
+    def remove(cls, conn, tag_id):
+        with closing(conn.cursor()) as cur:
+            cur.execute("DELETE FROM tag WHERE id = ?", (tag_id,))
+            conn.commit()
+
+    @classmethod
+    def get(cls, conn: Connection, id):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT * FROM tag WHERE id = ?", (id,))
+            row = cur.fetchone()
+            if row is None:
+                return None
+            else:
+                return cls.from_row(row)
+
+    @classmethod
+    def get_all_custom_tag(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT * FROM tag where type = 'custom'")
+            rows = cur.fetchall()
+            tags: list[Tag] = []
+            for row in rows:
+                tags.append(cls.from_row(row))
+            return tags
+
+    @classmethod
+    def get_all(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT * FROM tag")
+            rows = cur.fetchall()
+            tags: list[Tag] = []
+            for row in rows:
+                tags.append(cls.from_row(row))
+            return tags
+
+    @classmethod
+    def get_or_create(cls, conn: Connection, name: str, type: str):
+        assert name and type
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "SELECT tag.* FROM tag WHERE name = ? and type = ?", (name, type)
+            )
+            row = cur.fetchone()
+            if row is None:
+                tag = cls(name=name, score=0, type=type)
+                tag.save(conn)
+                return tag
+            else:
+                return cls.from_row(row)
+
+    @classmethod
+    def from_row(cls, row: tuple):
+        tag = cls(name=row[1], score=row[2], type=row[3], count=row[4], color=row[5])
+        tag.id = row[0]
+        return tag
+
+    @classmethod
+    def create_table(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                """CREATE TABLE IF NOT EXISTS tag (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT,
+            score INTEGER,
+            type TEXT,
+            count INTEGER,
+            UNIQUE(name, type) ON CONFLICT REPLACE
+            );
+            """
+            )
+            cur.execute("CREATE INDEX IF NOT EXISTS tag_idx_name ON tag(name)")
+            cur.execute(
+                """INSERT OR IGNORE INTO tag(name, score, type, count)
+                VALUES ("like", 0, "custom", 0);
+                """
+            )
+            try:
+                cur.execute(
+                    """ALTER TABLE tag
+                    ADD COLUMN color TEXT DEFAULT ''"""
+                )
+            except sqlite3.OperationalError as e:
+                pass
+
+
+class ImageTag:
+    def __init__(self, image_id: int, tag_id: int):
+        assert tag_id and image_id
+        self.image_id = image_id
+        self.tag_id = tag_id
+
+    def save(self, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "INSERT INTO image_tag (image_id, tag_id, created_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
+                (self.image_id, self.tag_id),
+            )
+
+    def save_or_ignore(self, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "INSERT OR IGNORE INTO image_tag (image_id, tag_id, created_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
+                (self.image_id, self.tag_id),
+            )
+
+    @classmethod
+    def get_tags_for_image(
+        cls,
+        conn: Connection,
+        image_id: int,
+        tag_id: Optional[int] = None,
+        type: Optional[str] = None,
+    ):
+        with closing(conn.cursor()) as cur:
+            query = "SELECT tag.* FROM tag INNER JOIN image_tag ON tag.id = image_tag.tag_id WHERE image_tag.image_id = ?"
+            params = [image_id]
+            if tag_id:
+                query += " AND image_tag.tag_id = ?"
+                params.append(tag_id)
+            if type:
+                query += " AND tag.type = ?"
+                params.append(type)
+            cur.execute(query, tuple(params))
+            rows = cur.fetchall()
+            return [Tag.from_row(x) for x in rows]
+
+    @classmethod
+    def get_images_for_tag(cls, conn: Connection, tag_id):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "SELECT image.* FROM image INNER JOIN image_tag ON image.id = image_tag.image_id WHERE image_tag.tag_id = ?",
+                (tag_id,),
+            )
+            rows = cur.fetchall()
+            images = []
+            for row in rows:
+                images.append(Image.from_row(row))
+            return images
+
+    @classmethod
+    def create_table(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                """CREATE TABLE IF NOT EXISTS image_tag (
+                            image_id INTEGER,
+                            tag_id INTEGER,
+                            FOREIGN KEY (image_id) REFERENCES image(id),
+                            FOREIGN KEY (tag_id) REFERENCES tag(id),
+                            PRIMARY KEY (image_id, tag_id)
+                        )"""
+            )
+            try:
+                cur.execute(
+                    """ALTER TABLE image_tag
+                    ADD COLUMN created_at TIMESTAMP"""
+                )
+                
+                cur.execute(
+                    """UPDATE image_tag
+                    SET created_at = CURRENT_TIMESTAMP
+                    WHERE created_at IS NULL"""
+                )
+            except sqlite3.OperationalError as e:
+                pass
+            
+    @classmethod
+    def get_images_by_tags(
+        cls,
+        conn: Connection,
+        tag_dict: Dict[str, List[int]],
+        limit: int = 500,
+        cursor="",
+        folder_paths: List[str] = None,
+    ) -> tuple[List[Image], Cursor]:
+        query = """
+            SELECT image.id, image.path, image.size,image.date
+            FROM image
+            INNER JOIN image_tag ON image.id = image_tag.image_id
+        """
+
+        where_clauses = []
+        params = []
+
+        for operator, tag_ids in tag_dict.items():
+            if operator == "and" and tag_dict["and"]:
+                where_clauses.append(
+                    "tag_id IN ({})".format(",".join("?" * len(tag_ids)))
+                )
+                params.extend(tag_ids)
+            elif operator == "not" and tag_dict["not"]:
+                where_clauses.append(
+                    """(image_id NOT IN (
+  SELECT image_id
+  FROM image_tag
+  WHERE tag_id IN ({})
+))""".format(
+                        ",".join("?" * len(tag_ids))
+                    )
+                )
+                params.extend(tag_ids)
+            elif operator == "or" and tag_dict["or"]:
+                where_clauses.append(
+                    """(image_id IN (
+  SELECT image_id
+  FROM image_tag
+  WHERE tag_id IN ({})
+  GROUP BY image_id
+  HAVING COUNT(DISTINCT tag_id) >= 1
+)
+)""".format(
+                        ",".join("?" * len(tag_ids))
+                    )
+                )
+                params.extend(tag_ids)    
+
+        if folder_paths:
+            folder_clauses = []
+            for folder_path in folder_paths:
+                folder_clauses.append("(image.path LIKE ?)")
+                params.append(os.path.join(folder_path, "%"))
+                print(folder_path)
+            where_clauses.append("(" + " OR ".join(folder_clauses) + ")")
+
+        if cursor:
+            where_clauses.append("(image.date < ?)")
+            params.append(cursor)
+        if where_clauses:
+            query += " WHERE " + " AND ".join(where_clauses)
+        query += " GROUP BY image.id"
+        if "and" in tag_dict and tag_dict['and']:
+            query += " HAVING COUNT(DISTINCT tag_id) = ?"
+            params.append(len(tag_dict["and"]))
+
+        query += " ORDER BY date DESC LIMIT ?"
+        params.append(limit)
+        api_cur = Cursor()
+        with closing(conn.cursor()) as cur:
+            cur.execute(query, params)
+            rows = cur.fetchall()
+            images = []
+            deleted_ids = []
+            for row in rows:
+                img = Image(id=row[0], path=row[1], size=row[2], date=row[3])
+                if os.path.exists(img.path):
+                    images.append(img)
+                else:
+                    deleted_ids.append(img.id)
+            Image.safe_batch_remove(conn, deleted_ids)
+            api_cur.has_next = len(rows) >= limit
+            if images:
+                api_cur.next = str(images[-1].date)
+            return images, api_cur
+
+    @classmethod
+    def batch_get_tags_by_path(
+        cls, conn: Connection, paths: List[str], type="custom"
+    ) -> Dict[str, List[Tag]]:
+        if not paths:
+            return {}
+        tag_dict = {}
+        with closing(conn.cursor()) as cur:
+            placeholders = ",".join("?" * len(paths))
+            query = f"""
+                SELECT image.path, tag.* FROM image_tag
+                INNER JOIN image ON image_tag.image_id = image.id
+                INNER JOIN tag ON image_tag.tag_id = tag.id
+                WHERE tag.type = '{type}' AND image.path IN ({placeholders})
+            """
+            cur.execute(query, paths)
+            rows = cur.fetchall()
+            for row in rows:
+                path = row[0]
+                tag = Tag.from_row(row[1:])
+                if path in tag_dict:
+                    tag_dict[path].append(tag)
+                else:
+                    tag_dict[path] = [tag]
+        return tag_dict
+
+    @classmethod
+    def remove(
+        cls,
+        conn: Connection,
+        image_id: Optional[int] = None,
+        tag_id: Optional[int] = None,
+    ) -> None:
+        assert image_id or tag_id
+        with closing(conn.cursor()) as cur:
+            if tag_id and image_id:
+                cur.execute(
+                    "DELETE FROM image_tag WHERE image_id = ? and tag_id = ?",
+                    (image_id, tag_id),
+                )
+            elif tag_id:
+                cur.execute("DELETE FROM image_tag WHERE tag_id = ?", (tag_id,))
+            else:
+                cur.execute("DELETE FROM image_tag WHERE image_id = ?", (image_id,))
+            conn.commit()
+
+
+class Folder:
+    def __init__(self, id: int, path: str, modified_date: str):
+        self.id = id
+        self.path = path
+        self.modified_date = modified_date
+
+    @classmethod
+    def create_table(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                """CREATE TABLE IF NOT EXISTS folders
+                        (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        path TEXT,
+                        modified_date TEXT)"""
+            )
+            cur.execute("CREATE INDEX IF NOT EXISTS folders_idx_path ON folders(path)")
+
+    @classmethod
+    def check_need_update(cls, conn: Connection, folder_path: str):
+        folder_path = os.path.normpath(folder_path)
+        with closing(conn.cursor()) as cur:
+            if not os.path.exists(folder_path):
+                return False
+            cur.execute("SELECT * FROM folders WHERE path=?", (folder_path,))
+            folder_record = cur.fetchone()  # 如果这个文件夹没有记录，或者修改时间与数据库不同，则需要修改
+            return not folder_record or (
+                folder_record[2] != get_modified_date(folder_path)
+            )
+
+    @classmethod
+    def update_modified_date_or_create(cls, conn: Connection, folder_path: str):
+        folder_path = os.path.normpath(folder_path)
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT * FROM folders WHERE path = ?", (folder_path,))
+            row = cur.fetchone()
+            if row:
+                cur.execute(
+                    "UPDATE folders SET modified_date = ? WHERE path = ?",
+                    (get_modified_date(folder_path), folder_path),
+                )
+            else:
+                cur.execute(
+                    "INSERT INTO folders (path, modified_date) VALUES (?, ?)",
+                    (folder_path, get_modified_date(folder_path)),
+                )
+
+    @classmethod
+    def get_expired_dirs(cls, conn: Connection):
+        dirs: List[str] = []
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT * FROM folders")
+            result_set = cur.fetchall()
+            extra_paths = ExtraPath.get_extra_paths(conn)
+            for ep in extra_paths:
+                if not find(result_set, lambda x: x[1] == ep.path):
+                    dirs.append(ep.path)
+            for row in result_set:
+                folder_path = row[1]
+                if (
+                    os.path.exists(folder_path)
+                    and get_modified_date(folder_path) != row[2]
+                ):
+                    dirs.append(folder_path)
+            return unique_by(dirs, os.path.normpath)
+
+    @classmethod
+    def remove_folder(cls, conn: Connection, folder_path: str):
+        folder_path = os.path.normpath(folder_path)
+        with closing(conn.cursor()) as cur:
+            cur.execute("DELETE FROM folders WHERE path = ?", (folder_path,))
+
+    @classmethod
+    def remove_all(cls, conn: Connection):
+        with closing(conn.cursor()) as cur:
+            cur.execute("DELETE FROM folders")
+            conn.commit()
+
+
+class ExtraPathType(Enum):
+    scanned = "scanned"
+    scanned_fixed = "scanned-fixed"
+    walk = "walk"
+    cli_only = "cli_access_only"
+
+
+class ExtraPath:
+    def __init__(self, path: str, types: Union[str, List[str]], alias = ''):
+        self.path = os.path.normpath(path)
+        self.types = types.split('+') if isinstance(types, str) else types
+        self.alias = alias
+
+    def save(self, conn):
+        type_str = '+'.join(self.types)
+        for type in self.types:
+            assert type in [ExtraPathType.walk.value, ExtraPathType.scanned.value, ExtraPathType.scanned_fixed.value]
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                "INSERT INTO extra_path (path, type, alias) VALUES (?, ?, ?) "
+                "ON CONFLICT (path) DO UPDATE SET type = excluded.type, alias = excluded.alias",
+                (self.path, type_str, self.alias),
+            )
+
+    @classmethod
+    def get_target_path(cls, conn, path) -> Optional['ExtraPath']:
+        path = os.path.normpath(path)
+        query = f"SELECT * FROM extra_path where path = ?"
+        params = (path,)
+        with closing(conn.cursor()) as cur:
+            cur.execute(query, params)
+            rows = cur.fetchall()
+            paths: List[ExtraPath] = []
+            for row in rows:
+                path = row[0]
+                if os.path.exists(path):
+                    paths.append(ExtraPath(*row))
+                else:                    
+                    sql = "DELETE FROM extra_path WHERE path = ?"
+                    cur.execute(sql, (path,))
+                    conn.commit()
+            return paths[0] if paths else None
+
+    @classmethod
+    def get_extra_paths(cls, conn) -> List["ExtraPath"]:
+        query = "SELECT * FROM extra_path"
+        with closing(conn.cursor()) as cur:
+            cur.execute(query)
+            rows = cur.fetchall()
+            paths: List[ExtraPath] = []
+            for row in rows:
+                path = row[0]
+                if os.path.exists(path):
+                    paths.append(ExtraPath(*row))
+                else:
+                    cls.remove(conn, path)
+            return paths
+
+    @classmethod
+    def remove(
+        cls,
+        conn,
+        path: str,
+        types: List[str] = None,
+        img_search_dirs: Optional[List[str]] = [],
+    ):
+        with closing(conn.cursor()) as cur:
+            path = os.path.normpath(path)
+
+            target = cls.get_target_path(conn, path)
+            if not target:
+                return
+            new_types = []
+            for type in target.types:
+                if type not in types:
+                    new_types.append(type)
+            if new_types:
+                target.types = new_types
+                target.save(conn)
+            else:
+                sql = "DELETE FROM extra_path WHERE path = ?"
+                cur.execute(sql, (path,))
+
+            if path not in img_search_dirs:
+                Folder.remove_folder(conn, path)
+            conn.commit()
+
+    @classmethod
+    def create_table(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                """CREATE TABLE IF NOT EXISTS extra_path (
+                            path TEXT PRIMARY KEY,
+                            type TEXT NOT NULL,
+                            alias TEXT DEFAULT ''
+                        )"""
+            )
+            try:
+                cur.execute(
+                    """ALTER TABLE extra_path
+                    ADD COLUMN alias TEXT DEFAULT ''"""
+                )
+            except sqlite3.OperationalError:
+                pass
+
+class DirCoverCache:
+    @classmethod
+    def create_table(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS dir_cover_cache (
+                    folder_path TEXT PRIMARY KEY,
+                    modified_time TEXT,
+                    media_files TEXT
+                )
+            """)
+
+    @classmethod
+    def is_cache_expired(cls, conn, folder_path):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT modified_time FROM dir_cover_cache WHERE folder_path = ?", (folder_path,))
+            result = cur.fetchone()
+
+        if not result:
+            return True
+
+        cached_time = datetime.fromisoformat(result[0])
+        folder_modified_time = os.path.getmtime(folder_path)
+        return datetime.fromtimestamp(folder_modified_time) > cached_time
+
+    @classmethod
+    def cache_media_files(cls, conn, folder_path, media_files):
+        media_files_json = json.dumps(media_files)
+        with closing(conn.cursor()) as cur:
+            cur.execute("""
+                INSERT INTO dir_cover_cache (folder_path, modified_time, media_files)
+                VALUES (?, ?, ?)
+                ON CONFLICT(folder_path) DO UPDATE SET modified_time = excluded.modified_time, media_files = excluded.media_files
+            """, (folder_path, datetime.now().isoformat(), media_files_json))
+            conn.commit()
+
+    @classmethod
+    def get_cached_media_files(cls, conn, folder_path):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT media_files FROM dir_cover_cache WHERE folder_path = ?", (folder_path,))
+            result = cur.fetchone()
+
+        if result:
+            media_files_json = result[0]
+            return json.loads(media_files_json)
+        else:
+            return []
+        
+
+class GlobalSetting:
+    @classmethod
+    def create_table(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                """CREATE TABLE IF NOT EXISTS global_setting (
+                            setting_json TEXT,
+                            name TEXT PRIMARY KEY,
+                            created_time TEXT,
+                            modified_time TEXT
+                        )"""
+            )
+
+    @classmethod
+    def get_setting(cls, conn, name):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT setting_json FROM global_setting WHERE name = ?", (name,))
+            result = cur.fetchone()
+            if result:
+                return json.loads(result[0])
+            else:
+                return None
+
+    @classmethod
+    def save_setting(cls, conn, name: str, setting: str):
+        json.loads(setting) # check if it is valid json
+        with closing(conn.cursor()) as cur:
+            cur.execute(
+                """INSERT INTO global_setting (setting_json, name, created_time, modified_time)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(name) DO UPDATE SET setting_json = excluded.setting_json, modified_time = excluded.modified_time
+                """,
+                (setting, name, datetime.now().isoformat(), datetime.now().isoformat()),
+            )
+            conn.commit()
+
+
+    @classmethod
+    def remove_setting(cls, conn, name: str):
+        with closing(conn.cursor()) as cur:
+            cur.execute("DELETE FROM global_setting WHERE name = ?", (name,))
+            conn.commit()
+
+    @classmethod
+    def get_all_settings(cls, conn):
+        with closing(conn.cursor()) as cur:
+            cur.execute("SELECT * FROM global_setting")
+            rows = cur.fetchall()
+            settings = {}
+            for row in rows:
+                settings[row[1]] = json.loads(row[0])
+            return settings

extensions/sd-webui-infinite-image-browsing/scripts/iib/db/update_image_data.py

@@ -0,0 +1,199 @@
+from contextlib import closing
+from typing import Dict, List
+from scripts.iib.db.datamodel import Image as DbImg, Tag, ImageTag, DataBase, Folder
+import os
+from scripts.iib.tool import (
+    is_valid_media_path,
+    get_modified_date,
+    get_video_type,
+    is_dev,
+    get_modified_date,
+    is_image_file,
+    case_insensitive_get
+)
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+from scripts.iib.logger import logger
+from scripts.iib.parsers.index import parse_image_info
+from scripts.iib.plugin import plugin_inst_map
+
+# 定义一个函数来获取图片文件的EXIF数据
+def get_exif_data(file_path):
+    if get_video_type(file_path):
+        return ImageGenerationInfo()
+    try:
+        return parse_image_info(file_path)
+    except Exception as e:
+        if is_dev:
+            logger.error("get_exif_data %s", e)
+    return ImageGenerationInfo()
+
+
+def update_image_data(search_dirs: List[str], is_rebuild = False):
+    conn = DataBase.get_conn()
+    tag_incr_count_rec: Dict[int, int] = {}
+
+    if is_rebuild:
+        Folder.remove_all(conn)
+
+    def safe_save_img_tag(img_tag: ImageTag):
+        tag_incr_count_rec[img_tag.tag_id] = (
+            tag_incr_count_rec.get(img_tag.tag_id, 0) + 1
+        )
+        img_tag.save_or_ignore(conn)  # 原先用来处理一些意外，但是写的正确完全没问题,去掉了try catch
+
+    # 递归处理每个文件夹
+    def process_folder(folder_path: str):
+        if not Folder.check_need_update(conn, folder_path):
+            return
+        print(f"Processing folder: {folder_path}")
+        for filename in os.listdir(folder_path):
+            file_path = os.path.normpath(os.path.join(folder_path, filename))
+            try:
+
+                if os.path.isdir(file_path):
+                    process_folder(file_path)
+                elif is_valid_media_path(file_path):
+                    build_single_img_idx(conn, file_path, is_rebuild, safe_save_img_tag)
+                # neg暂时跳过感觉个没人会搜索这个
+            except Exception as e:
+                logger.error("Tag generation failed. Skipping this file. file:%s error: %s", file_path, e)
+        # 提交对数据库的更改
+        Folder.update_modified_date_or_create(conn, folder_path)
+        conn.commit()
+
+    for dir in search_dirs:
+        process_folder(dir)
+        conn.commit()
+    for tag_id in tag_incr_count_rec:
+        tag = Tag.get(conn, tag_id)
+        tag.count += tag_incr_count_rec[tag_id]
+        tag.save(conn)
+    conn.commit()
+
+def add_image_data_single(file_path):
+    conn = DataBase.get_conn()
+    tag_incr_count_rec: Dict[int, int] = {}
+
+    def safe_save_img_tag(img_tag: ImageTag):
+        tag_incr_count_rec[img_tag.tag_id] = (
+            tag_incr_count_rec.get(img_tag.tag_id, 0) + 1
+        )
+        img_tag.save_or_ignore(conn)
+
+    file_path = os.path.normpath(file_path)
+    try:
+        if not is_valid_media_path(file_path):
+            return
+        build_single_img_idx(conn, file_path, False, safe_save_img_tag)
+        # neg暂时跳过感觉个没人会搜索这个
+    except Exception as e:
+        logger.error("Tag generation failed. Skipping this file. file:%s error: %s", file_path, e)
+        conn.commit()
+
+    for tag_id in tag_incr_count_rec:
+        tag = Tag.get(conn, tag_id)
+        tag.count += tag_incr_count_rec[tag_id]
+        tag.save(conn)
+    conn.commit()
+
+def rebuild_image_index(search_dirs: List[str]):
+    conn = DataBase.get_conn()
+    with closing(conn.cursor()) as cur:
+        cur.execute(
+            """DELETE FROM image_tag
+            WHERE image_tag.tag_id IN (
+                SELECT tag.id FROM tag WHERE tag.type <> 'custom'
+            )
+            """
+        )
+        cur.execute("""DELETE FROM tag WHERE tag.type <> 'custom'""")
+        conn.commit()
+        update_image_data(search_dirs=search_dirs, is_rebuild=True)
+
+
+def get_extra_meta_keys_from_plugins(source_identifier: str):
+    try:
+        plugin = plugin_inst_map.get(source_identifier)
+        if plugin:
+            return plugin.extra_convert_to_tag_meta_keys
+    except Exception as e:
+        logger.error("get_extra_meta_keys_from_plugins %s", e)
+    return []
+
+def build_single_img_idx(conn, file_path, is_rebuild, safe_save_img_tag):
+    img = DbImg.get(conn, file_path)
+    parsed_params = None
+    if is_rebuild:
+        info = get_exif_data(file_path)
+        parsed_params = info.params
+        if not img:
+            img = DbImg(
+                file_path,
+                info.raw_info,
+                os.path.getsize(file_path),
+                get_modified_date(file_path),
+            )
+            img.save(conn)
+    else:
+        if img:  # 已存在的跳过
+            if img.date == get_modified_date(img.path):
+                return
+            else:
+                DbImg.safe_batch_remove(conn=conn, image_ids=[img.id])
+        info = get_exif_data(file_path)
+        parsed_params = info.params
+        img = DbImg(
+            file_path,
+            info.raw_info,
+            os.path.getsize(file_path),
+            get_modified_date(file_path),
+        )
+        img.save(conn)
+
+    if not parsed_params:
+        return
+    meta = parsed_params.meta
+    lora = parsed_params.extra.get("lora", [])
+    lyco = parsed_params.extra.get("lyco", [])
+    pos = parsed_params.pos_prompt
+    size_tag = Tag.get_or_create(
+        conn,
+        str(meta.get("Size-1", 0)) + " * " + str(meta.get("Size-2", 0)),
+        type="size",
+    )
+    safe_save_img_tag(ImageTag(img.id, size_tag.id))
+    media_type_tag = Tag.get_or_create(conn, "Image" if is_image_file(file_path) else "Video", 'Media Type')
+    safe_save_img_tag(ImageTag(img.id, media_type_tag.id))
+    keys = [
+        "Model",
+        "Sampler",
+        "Source Identifier",
+        "Postprocess upscale by",
+        "Postprocess upscaler",
+        "Size",
+        "Refiner",
+        "Hires upscaler"
+    ]
+    keys += get_extra_meta_keys_from_plugins(meta.get("Source Identifier", ""))
+    for k in keys:
+        v = case_insensitive_get(meta, k)
+        if not v:
+            continue
+        
+        tag = Tag.get_or_create(conn, str(v), k)
+        safe_save_img_tag(ImageTag(img.id, tag.id))
+        if "Hires upscaler" == k:
+            tag = Tag.get_or_create(conn, 'Hires All', k)
+            safe_save_img_tag(ImageTag(img.id, tag.id))
+        elif "Refiner" == k:
+            tag = Tag.get_or_create(conn, 'Refiner All', k)
+            safe_save_img_tag(ImageTag(img.id, tag.id))
+    for i in lora:
+        tag = Tag.get_or_create(conn, i["name"], "lora")
+        safe_save_img_tag(ImageTag(img.id, tag.id))
+    for i in lyco:
+        tag = Tag.get_or_create(conn, i["name"], "lyco")
+        safe_save_img_tag(ImageTag(img.id, tag.id))
+    for k in pos:
+        tag = Tag.get_or_create(conn, k, "pos")
+        safe_save_img_tag(ImageTag(img.id, tag.id))

extensions/sd-webui-infinite-image-browsing/scripts/iib/dir_cover_cache.py

@@ -0,0 +1,53 @@
+import os
+from scripts.iib.db.datamodel  import DirCoverCache, DataBase
+from scripts.iib.tool import get_created_date_by_stat, get_formatted_date, is_valid_media_path, get_video_type, birthtime_sort_key_fn
+
+def get_top_4_media_info(folder_path):
+    """
+    获取给定文件夹路径下的前4个媒体文件的完整路径。
+
+    参数:
+    folder_path (str): 文件夹的路径。
+
+    返回值:
+    list: 包含前4个媒体文件完整路径的列表。
+    """
+    conn = DataBase.get_conn()
+    if DirCoverCache.is_cache_expired(conn, folder_path):
+        media_files = get_media_files_from_folder(folder_path)
+        DirCoverCache.cache_media_files(conn, folder_path, media_files)
+    else:
+        media_files = DirCoverCache.get_cached_media_files(conn, folder_path)
+
+    return media_files[:4]
+
+def get_media_files_from_folder(folder_path):
+    """
+    从文件夹中获取媒体文件的完整路径。
+
+    参数:
+    folder_path (str): 文件夹的路径。
+
+    返回值:
+    list: 包含媒体文件完整路径的列表。
+    """
+    media_files = []
+    with os.scandir(folder_path) as entries:
+        for entry in sorted(entries, key=birthtime_sort_key_fn, reverse=True):
+            if entry.is_file() and is_valid_media_path(entry.path):
+                name = os.path.basename(entry.path)
+                stat = entry.stat()
+                date = get_formatted_date(stat.st_mtime)
+                created_time = get_created_date_by_stat(stat)
+                media_files.append({
+                    "fullpath": entry.path,
+                    "media_type": "video" if get_video_type(entry.path) else "image",
+                    "type": "file",
+                    "date": date,
+                    "created_time": created_time,
+                    "name": name,
+                })
+            if len(media_files) > 3:
+                return media_files
+    
+    return media_files

extensions/sd-webui-infinite-image-browsing/scripts/iib/fastapi_video.py

@@ -0,0 +1,86 @@
+import os
+from typing import BinaryIO
+
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.responses import StreamingResponse
+from scripts.iib.tool import get_video_type
+
+video_file_handler = {}
+
+def close_video_file_reader(path):
+    if not get_video_type(path):
+        return
+    try:
+        video_file_handler[path].close()
+    except Exception as e:
+        print(f"close file error: {e}")
+    
+
+def send_bytes_range_requests(
+    file_path, start: int, end: int, chunk_size: int = 10_000
+):
+    """Send a file in chunks using Range Requests specification RFC7233
+
+    `start` and `end` parameters are inclusive due to specification
+    """
+    with open(file_path, mode="rb") as f:
+        video_file_handler[file_path] = f
+        f.seek(start)
+        while (pos := f.tell()) <= end:
+            read_size = min(chunk_size, end + 1 - pos)
+            yield f.read(read_size)
+
+
+def _get_range_header(range_header: str, file_size: int) -> tuple[int, int]:
+    def _invalid_range():
+        return HTTPException(
+            status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
+            detail=f"Invalid request range (Range:{range_header!r})",
+        )
+
+    try:
+        h = range_header.replace("bytes=", "").split("-")
+        start = int(h[0]) if h[0] != "" else 0
+        end = int(h[1]) if h[1] != "" else file_size - 1
+    except ValueError:
+        raise _invalid_range()
+
+    if start > end or start < 0 or end > file_size - 1:
+        raise _invalid_range()
+    return start, end
+
+
+def range_requests_response(
+    request: Request, file_path: str, content_type: str
+):
+    """Returns StreamingResponse using Range Requests of a given file"""
+
+    file_size = os.stat(file_path).st_size
+    range_header = request.headers.get("range")
+
+    headers = {
+        "content-type": content_type,
+        "accept-ranges": "bytes",
+        "content-encoding": "identity",
+        "content-length": str(file_size),
+        "access-control-expose-headers": (
+            "content-type, accept-ranges, content-length, "
+            "content-range, content-encoding"
+        ),
+    }
+    start = 0
+    end = file_size - 1
+    status_code = status.HTTP_200_OK
+
+    if range_header is not None:
+        start, end = _get_range_header(range_header, file_size)
+        size = end - start + 1
+        headers["content-length"] = str(size)
+        headers["content-range"] = f"bytes {start}-{end}/{file_size}"
+        status_code = status.HTTP_206_PARTIAL_CONTENT
+
+    return StreamingResponse(
+        send_bytes_range_requests(file_path, start, end),
+        headers=headers,
+        status_code=status_code,
+    )

extensions/sd-webui-infinite-image-browsing/scripts/iib/img_cache_gen.py

@@ -0,0 +1,58 @@
+import hashlib
+import os
+from typing import List
+from scripts.iib.tool import get_formatted_date, get_cache_dir, is_image_file
+from concurrent.futures import ThreadPoolExecutor
+import time
+from PIL import Image
+
+def generate_image_cache(dirs, size:str, verbose=False):
+  start_time = time.time()
+  cache_base_dir = get_cache_dir()
+
+  def process_image(item):
+    if item.is_dir():
+      verbose and print(f"Processing directory: {item.path}")
+      for sub_item in os.scandir(item.path):
+        process_image(sub_item)
+      return
+    if not os.path.exists(item.path) or not is_image_file(item.path):
+      return
+
+    try:
+      path = os.path.normpath(item.path)
+      stat = item.stat()
+      t = get_formatted_date(stat.st_mtime)
+      hash_dir = hashlib.md5((path + t).encode("utf-8")).hexdigest()
+      cache_dir = os.path.join(cache_base_dir, "iib_cache", hash_dir)
+      cache_path = os.path.join(cache_dir, f"{size}.webp")
+
+      if os.path.exists(cache_path):
+          verbose and print(f"Image cache already exists: {path}")
+          return
+
+      if os.path.getsize(path) < 64 * 1024:
+          verbose and print(f"Image size less than 64KB: {path}", "skip")
+          return
+        
+      with Image.open(path) as img:
+          w, h = size.split("x")
+          img.thumbnail((int(w), int(h)))
+          os.makedirs(cache_dir, exist_ok=True)
+          img.save(cache_path, "webp")
+
+      verbose and print(f"Image cache generated: {path}")
+    except Exception as e:
+      print(f"Error generating image cache: {path}")
+      print(e)
+
+  with ThreadPoolExecutor() as executor:
+    for dir_path in dirs:
+      folder_listing: List[os.DirEntry] = os.scandir(dir_path)
+      for item in folder_listing:
+        executor.submit(process_image, item)
+
+  print("Image cache generation completed. ✨")
+  end_time = time.time()
+  execution_time = end_time - start_time
+  print(f"Execution time: {execution_time} seconds")

extensions/sd-webui-infinite-image-browsing/scripts/iib/logger.py

@@ -0,0 +1,20 @@
+
+from scripts.iib.tool import is_dev,cwd
+
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+
+file_handler = logging.FileHandler(f"{cwd}/log.log")
+file_handler.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+console_handler.setFormatter(formatter)
+file_handler.setFormatter(formatter)
+
+logger.addHandler(file_handler)
+if is_dev:
+    logger.addHandler(console_handler)

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/comfyui.py

@@ -0,0 +1,51 @@
+from PIL import Image
+
+from scripts.iib.tool import (
+    comfyui_exif_data_to_str,
+    is_img_created_by_comfyui,
+    is_img_created_by_comfyui_with_webui_gen_info,
+    get_comfyui_exif_data,
+    parse_generation_parameters,
+    read_sd_webui_gen_info_from_image,
+)
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+from scripts.iib.logger import logger
+
+
+class ComfyUIParser:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def parse(clz, img, file_path):
+        info = ""
+        params = None
+        if not clz.test(img, file_path):
+            raise Exception("The input image does not match the current parser.")
+        try:
+            if is_img_created_by_comfyui_with_webui_gen_info(img):
+                info = read_sd_webui_gen_info_from_image(img, file_path)
+                info += ", Source Identifier: ComfyUI"
+                params = parse_generation_parameters(info)
+            else:
+                params = get_comfyui_exif_data(img)
+                info = comfyui_exif_data_to_str(params)
+        except Exception as e:                        
+            logger.error('parse comfyui image failed. prompt:')
+            logger.error(img.info.get('prompt'))
+            return ImageGenerationInfo()
+        return ImageGenerationInfo(
+            info,
+            ImageGenerationParams(
+                meta=params["meta"], pos_prompt=params["pos_prompt"], extra=params
+            ),
+        )
+
+    @classmethod
+    def test(clz, img: Image, file_path: str) -> bool:
+        try:
+            return is_img_created_by_comfyui(
+                img
+            ) or is_img_created_by_comfyui_with_webui_gen_info(img)
+        except Exception:
+            return False

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/fooocus.py

@@ -0,0 +1,77 @@
+import os
+import re
+from PIL import Image
+
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+from scripts.iib.tool import omit, parse_generation_parameters, unique_by
+
+
+def remove_extra_spaces(text):
+    return re.sub(r"\s+", " ", text)
+
+
+def get_log_file(file_path: str):
+    dir = os.path.dirname(file_path)
+    with open(os.path.join(dir, "log.html")) as f:
+        return f.read()
+
+lora_re = re.compile("LoRA \d+", re.IGNORECASE)
+
+class FooocusParser:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def parse(clz, img: Image, file_path):
+        if not clz.test(img, file_path):
+            raise Exception("The input image does not match the current parser.")
+        from lxml import etree
+
+        log = get_log_file(file_path)
+        root = etree.HTML(log)
+        id = str(os.path.basename(file_path)).replace(".", "_")
+        metadata = root.xpath(f'//div[@id="{id}"]/descendant::table[@class="metadata"]')
+        tr_elements = metadata[0].xpath(".//tr")
+        lora_list = []
+        # As a workaround to bypass parsing errors in the parser.
+        # https://github.com/jiw0220/stable-diffusion-image-metadata/blob/00b8d42d4d1a536862bba0b07c332bdebb2a0ce5/src/index.ts#L130
+        metadata_list_str = "Steps: Unknown , Source Identifier: Fooocus ,"
+        params = {"meta": {"Source Identifier": "Fooocus"}}
+        for tr in tr_elements:
+            label = tr.xpath('.//td[@class="label" or @class="key"]/text()')
+            value = tr.xpath('.//td[@class="value"]/text()')
+            if label:
+                k = label[0]
+                v = value[0] if value else "None"
+                if k == "Fooocus V2 Expansion":
+                    continue
+                if k == "Prompt" or k == "Negative Prompt":
+                    params[k] = remove_extra_spaces(v.replace("\n", "").strip())
+                else:
+                    v = v.replace(",", "，")
+                    params["meta"][k] = v
+                    metadata_list_str += f" {k}: {v},"
+                if lora_re.search(k):
+                    lora_list.append({ "name": v.strip(), "value": 1 })
+        params["meta"]["Model"] = params["meta"]["Base Model"]
+        params["meta"]["Size"] = str(params["meta"]["Resolution"]).replace("(", "").replace(")", "").replace("，", " * ")
+        metadata_list_str = metadata_list_str.strip()
+        info = f"""{params['Prompt']}\nNegative prompt: {params['Negative Prompt']}\n{metadata_list_str}""".strip()
+        return ImageGenerationInfo(
+            info,
+            ImageGenerationParams(
+                meta=params["meta"],
+                pos_prompt=parse_generation_parameters(info)["pos_prompt"],
+                extra={
+                    "lora": unique_by(lora_list, lambda x: x["name"].lower())
+                }
+            ),
+        )
+
+    @classmethod
+    def test(clz, img: Image, file_path: str):
+        filename = os.path.basename(file_path)
+        try:
+            return get_log_file(file_path).find(filename) != -1
+        except Exception as e:
+            return False

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/index.py

@@ -0,0 +1,40 @@
+import os
+from scripts.iib.parsers.comfyui import ComfyUIParser
+from scripts.iib.parsers.sd_webui import SdWebUIParser
+from scripts.iib.parsers.fooocus import FooocusParser
+from scripts.iib.parsers.novelai import NovelAIParser
+from scripts.iib.parsers.model import ImageGenerationInfo
+from scripts.iib.parsers.stable_swarm_ui import StableSwarmUIParser
+from scripts.iib.parsers.invoke_ai import InvokeAIParser
+from scripts.iib.parsers.sd_webui_stealth import SdWebUIStealthParser
+from scripts.iib.logger import logger
+from PIL import Image
+from scripts.iib.plugin import plugin_insts
+import traceback
+
+
+def parse_image_info(image_path: str) -> ImageGenerationInfo:
+    enable_stealth_parser = os.getenv('IIB_ENABLE_SD_WEBUI_STEALTH_PARSER', 'false').lower() == 'true'
+    parsers = plugin_insts + [
+        ComfyUIParser,
+        FooocusParser,
+        NovelAIParser,
+        InvokeAIParser,
+        StableSwarmUIParser,
+    ]
+    
+    if enable_stealth_parser:
+        parsers.append(SdWebUIStealthParser)
+    
+    parsers.append(SdWebUIParser)
+    with Image.open(image_path) as img:
+        for parser in parsers:
+            if parser.test(img, image_path):
+                try:
+                    return parser.parse(img, image_path)
+                except Exception as e:
+                    logger.error(e, stack_info=True)
+                    print(e)
+                    print(traceback.format_exc())
+                    return ImageGenerationInfo()
+        raise Exception("matched parser is not found")

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/invoke_ai.py

@@ -0,0 +1,64 @@
+from PIL import Image
+import json
+
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+from scripts.iib.tool import omit, parse_generation_parameters, unique_by
+
+class InvokeAIParser:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def parse(clz, img: Image, file_path):
+        if not clz.test(img, file_path):
+            raise Exception("The input image does not match the current parser.")
+        raw_infos = json.loads(img.info["invokeai_graph"])
+        core_metadata = {}
+        for key in raw_infos['nodes']:
+            if key.startswith("core_metadata"):
+                core_metadata = raw_infos['nodes'][key]
+                break
+          
+        positive_prompt = core_metadata.get("positive_prompt", "None")
+        negative_prompt = core_metadata.get("negative_prompt", "None")
+        steps = core_metadata.get("steps", 'Unknown')
+        cfg_scale = core_metadata.get("cfg_scale", 'Unknown')
+        model_name = core_metadata.get("model", {}).get("name", "Unknown")
+        model_hash = core_metadata.get("model", {}).get("hash", "Unknown")
+        
+        meta_kv = [
+            f"Steps: {steps}",
+            "Source Identifier: InvokeAI",
+            f"CFG scale: {cfg_scale}",
+            f"Model: {model_name}",
+            f"Model hash: {model_hash}",
+        ]
+
+        for key in core_metadata:
+            if key not in ["positive_prompt", "negative_prompt", "steps", "cfg_scale", "model"]:
+                val = core_metadata[key]
+                if bool(val):
+                    meta_kv.append(f"{key}: {val}")
+        
+        meta = ", ".join(meta_kv)
+        meta_obj = {}
+        for kv in meta_kv:
+            k, v = kv.split(": ", 1)
+            meta_obj[k] = v
+        info = f"{positive_prompt}\nNegative prompt: {negative_prompt}\n{meta}"
+        
+        return ImageGenerationInfo(
+            info,
+            ImageGenerationParams(
+                meta=meta_obj,
+                pos_prompt=parse_generation_parameters(info)["pos_prompt"],
+                # extra=params
+            ),
+        )
+
+    @classmethod
+    def test(clz, img: Image, file_path: str):
+        try:
+            return 'invokeai_graph' in img.info
+        except Exception as e:
+            return False

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/model.py

@@ -0,0 +1,18 @@
+from scripts.iib.tool import omit
+
+
+class ImageGenerationParams:
+    def __init__(self, meta: dict = {}, pos_prompt: list = [], extra: dict = {}) -> None:
+        self.meta = meta
+        self.pos_prompt = pos_prompt
+        self.extra = omit(extra, ["meta", "pos_prompt"])
+
+
+class ImageGenerationInfo:
+    def __init__(
+        self,
+        raw_info: str = "",
+        params: ImageGenerationParams = ImageGenerationParams(),
+    ):
+        self.raw_info = raw_info
+        self.params = params

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/novelai.py

@@ -0,0 +1,44 @@
+import json
+from PIL import Image
+
+from scripts.iib.tool import (
+    parse_generation_parameters,
+    replace_punctuation
+)
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+
+
+class NovelAIParser:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def parse(clz, img, file_path):
+        info = ""
+        params = None
+        if not clz.test(img, file_path):
+            raise Exception("The input image does not match the current parser.")
+        data = json.loads(img.info.get('Comment'))
+        meta_kv = [f"""Steps: {data["steps"]}, Source Identifier: NovelAI"""]
+        for key, value in data.items():
+            if key not in ["prompt"]:
+                value = replace_punctuation(str(value))
+                meta_kv.append(f"{key}: {value}")
+        meta = ', '.join(meta_kv)
+        info = data["prompt"] + '\n' + meta
+
+        params = parse_generation_parameters(info)
+
+        return ImageGenerationInfo(
+            info,
+            ImageGenerationParams(
+                meta=params["meta"], pos_prompt=params["pos_prompt"]
+            ),
+        )
+
+    @classmethod
+    def test(clz, img: Image, file_path: str) -> bool:
+        try:
+            return img.info.get('Software') == 'NovelAI' and isinstance(img.info.get('Comment'), str)
+        except Exception:
+            return False

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/sd_webui.py

@@ -0,0 +1,35 @@
+from PIL import Image
+
+from scripts.iib.tool import (
+    parse_generation_parameters,
+    read_sd_webui_gen_info_from_image,
+)
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+
+
+class SdWebUIParser:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def parse(clz, img: Image, file_path):
+        if not clz.test(img, file_path):
+            raise Exception("The input image does not match the current parser.")
+        info = read_sd_webui_gen_info_from_image(img, file_path)
+        if not info:
+            return ImageGenerationInfo()
+        info += ", Source Identifier: Stable Diffusion web UI"
+        params = parse_generation_parameters(info)
+        return ImageGenerationInfo(
+            info,
+            ImageGenerationParams(
+                meta=params["meta"], pos_prompt=params["pos_prompt"], extra=params
+            ),
+        )
+
+    @classmethod
+    def test(clz, img: Image, file_path: str):
+        try:
+            return True
+        except Exception as e:
+            return False

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/sd_webui_stealth.py

@@ -0,0 +1,157 @@
+from PIL import Image
+import gzip
+from scripts.iib.tool import (
+    parse_generation_parameters,
+    read_sd_webui_gen_info_from_image,
+)
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+# https://github.com/neggles/sd-webui-stealth-pnginfo/blob/main/scripts/stealth_pnginfo.py
+def read_info_from_image_stealth(image, fast_check=False):
+    width, height = image.size
+    pixels = image.load()
+
+    has_alpha = True if image.mode == 'RGBA' else False
+    mode = None
+    compressed = False
+    binary_data = ''
+    buffer_a = ''
+    buffer_rgb = ''
+    index_a = 0
+    index_rgb = 0
+    sig_confirmed = False
+    confirming_signature = True
+    reading_param_len = False
+    reading_param = False
+    read_end = False
+    cyc_count = 0
+    for x in range(width):
+        for y in range(height):
+            if has_alpha:
+                r, g, b, a = pixels[x, y]
+                buffer_a += str(a & 1)
+                index_a += 1
+            else:
+                r, g, b = pixels[x, y]
+            buffer_rgb += str(r & 1)
+            buffer_rgb += str(g & 1)
+            buffer_rgb += str(b & 1)
+            index_rgb += 3
+            cyc_count += 1
+            if fast_check and cyc_count> 256:
+                return False
+            if confirming_signature:
+                if index_a == len('stealth_pnginfo') * 8:
+                    decoded_sig = bytearray(int(buffer_a[i:i + 8], 2) for i in
+                                            range(0, len(buffer_a), 8)).decode('utf-8', errors='ignore')
+                    if decoded_sig in {'stealth_pnginfo', 'stealth_pngcomp'}:
+                        confirming_signature = False
+                        sig_confirmed = True
+                        if fast_check:
+                            return True
+                        reading_param_len = True
+                        mode = 'alpha'
+                        if decoded_sig == 'stealth_pngcomp':
+                            compressed = True
+                        buffer_a = ''
+                        index_a = 0
+                    else:
+                        read_end = True
+                        if fast_check:
+                            return False
+                        break
+                elif index_rgb == len('stealth_pnginfo') * 8:
+                    decoded_sig = bytearray(int(buffer_rgb[i:i + 8], 2) for i in
+                                            range(0, len(buffer_rgb), 8)).decode('utf-8', errors='ignore')
+                    if decoded_sig in {'stealth_rgbinfo', 'stealth_rgbcomp'}:
+                        confirming_signature = False
+                        sig_confirmed = True
+                        if fast_check:
+                            return True
+                        reading_param_len = True
+                        mode = 'rgb'
+                        if decoded_sig == 'stealth_rgbcomp':
+                            compressed = True
+                        buffer_rgb = ''
+                        index_rgb = 0
+            elif reading_param_len:
+                if mode == 'alpha':
+                    if index_a == 32:
+                        param_len = int(buffer_a, 2)
+                        reading_param_len = False
+                        reading_param = True
+                        buffer_a = ''
+                        index_a = 0
+                else:
+                    if index_rgb == 33:
+                        pop = buffer_rgb[-1]
+                        buffer_rgb = buffer_rgb[:-1]
+                        param_len = int(buffer_rgb, 2)
+                        reading_param_len = False
+                        reading_param = True
+                        buffer_rgb = pop
+                        index_rgb = 1
+            elif reading_param:
+                if mode == 'alpha':
+                    if index_a == param_len:
+                        binary_data = buffer_a
+                        read_end = True
+                        break
+                else:
+                    if index_rgb >= param_len:
+                        diff = param_len - index_rgb
+                        if diff < 0:
+                            buffer_rgb = buffer_rgb[:diff]
+                        binary_data = buffer_rgb
+                        read_end = True
+                        break
+            else:
+                # impossible
+                read_end = True
+                if fast_check:
+                    return False
+                break
+        if read_end:
+            break
+    if sig_confirmed and binary_data != '':
+        if fast_check:
+            return True
+        # Convert binary string to UTF-8 encoded text
+        byte_data = bytearray(int(binary_data[i:i + 8], 2) for i in range(0, len(binary_data), 8))
+        try:
+            if compressed:
+                decoded_data = gzip.decompress(bytes(byte_data)).decode('utf-8')
+            else:
+                decoded_data = byte_data.decode('utf-8', errors='ignore')
+            geninfo = decoded_data
+        except:
+            pass
+    return geninfo
+ 
+
+
+class SdWebUIStealthParser:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def parse(clz, img: Image, file_path):
+        if not clz.test(img, file_path):
+            raise Exception("The input image does not match the current parser.")
+        info = read_info_from_image_stealth(img)
+        if not info:
+            return ImageGenerationInfo()
+        info += ", Source Identifier: Stable Diffusion web UI(Stealth)"
+        params = parse_generation_parameters(info)
+        return ImageGenerationInfo(
+            info,
+            ImageGenerationParams(
+                meta=params["meta"], pos_prompt=params["pos_prompt"], extra=params
+            ),
+        )
+
+    @classmethod
+    def test(clz, img: Image, file_path: str):
+        try:
+            return bool(read_info_from_image_stealth(img, fast_check=True))
+        except Exception as e:
+            return False

extensions/sd-webui-infinite-image-browsing/scripts/iib/parsers/stable_swarm_ui.py

@@ -0,0 +1,61 @@
+from PIL import Image
+
+import piexif
+import piexif.helper
+from scripts.iib.tool import parse_generation_parameters, replace_punctuation
+from scripts.iib.parsers.model import ImageGenerationInfo, ImageGenerationParams
+from PIL.ExifTags import TAGS
+import json
+
+
+class StableSwarmUIParser:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def get_exif_data(clz, image: Image) -> str:
+        items = image.info or {}
+
+        if "exif" in items:
+            exif = piexif.load(items["exif"])
+            exif_bytes = (
+                (exif or {}).get("Exif", {}).get(piexif.ExifIFD.UserComment, b"")
+            )
+
+        unicode_start = exif_bytes.find(b"UNICODE")
+        if unicode_start == -1:
+            raise ValueError("'UNICODE' markup isn't found")
+
+        unicode_data = exif_bytes[unicode_start + len("UNICODE") + 1 :]
+        geninfo = unicode_data.decode("utf-16")
+        return geninfo
+
+    @classmethod
+    def parse(clz, img: Image, file_path):
+        if not clz.test(img, file_path):
+            raise Exception("The input image does not match the current parser.")
+        exif_data = json.loads(clz.get_exif_data(img))["sui_image_params"]
+        prompt = exif_data.pop("prompt")
+        negativeprompt = exif_data.pop("negativeprompt")
+        steps = exif_data.pop("steps")
+        meta_kv = [f"Steps: {steps}", "Source Identifier: StableSwarmUI"]
+        for key, value in exif_data.items():
+            value = replace_punctuation(str(value))
+            meta_kv.append(f"{key}: {value}")
+        meta = ", ".join(meta_kv)
+        info = "\n".join([prompt, f"Negative prompt: {negativeprompt}", meta])
+        params = parse_generation_parameters(info)
+        return ImageGenerationInfo(
+            info,
+            ImageGenerationParams(
+                meta=params["meta"], pos_prompt=params["pos_prompt"], extra=params
+            ),
+        )
+
+    @classmethod
+    def test(clz, img: Image, file_path: str):
+        try:
+            exif = clz.get_exif_data(img)
+            return exif.find("sui_image_params") != -1
+        except Exception as e:
+            return False

extensions/sd-webui-infinite-image-browsing/scripts/iib/plugin.py

@@ -0,0 +1,36 @@
+import os
+import importlib.util
+import sys
+from scripts.iib.tool import cwd
+
+def load_plugins(plugin_dir):
+    if not os.path.exists(plugin_dir):
+        return []
+    plugins = []
+    for filename in os.listdir(plugin_dir):
+        main_module_path = os.path.join(plugin_dir, filename, 'main.py')
+        if not os.path.exists(main_module_path):
+            continue
+        spec = importlib.util.spec_from_file_location('main', main_module_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        plugins.append(module)
+    return plugins
+
+plugin_insts = []
+plugin_inst_map = {}
+# 使用插件
+try:
+    plugin_dir = os.path.normpath(os.path.join(cwd, 'plugins'))
+    plugins = load_plugins(plugin_dir)
+    sys.path.append(plugin_dir)
+    for plugin in plugins:
+        try:
+            res = plugin.Main()
+            plugin_insts.append(res)
+            plugin_inst_map[res.source_identifier] = res
+            print(f'IIB loaded plugin: {res.name}')
+        except Exception as e:
+            print(f'Error running plugin {plugin.__class__.__name__}: {e}')
+except Exception as e:
+    print(f'Error loading plugins: {e}')

extensions/sd-webui-infinite-image-browsing/scripts/iib/seq.py

@@ -0,0 +1,21 @@
+class Seq:
+    def __init__(self, iterable):
+        self.iterable = iterable
+
+    def map(self, func):
+        return Seq(func(item) for item in self.iterable)
+
+    def filter(self, predicate):
+        return Seq(item for item in self.iterable if predicate(item))
+
+    def to_list(self):
+        return list(self.iterable)
+
+    def __iter__(self):
+        return iter(self.iterable)
+
+    def __repr__(self):
+        return f"Seq({repr(self.iterable)})"
+
+def seq(iterable):
+    return Seq(iterable)

extensions/sd-webui-infinite-image-browsing/scripts/iib/tool.py

@@ -0,0 +1,746 @@
+import ctypes
+from datetime import datetime
+import os
+import platform
+import re
+import tempfile
+import subprocess
+from typing import Dict, List
+import sys
+import piexif
+import piexif.helper
+import json
+import zipfile
+from PIL import Image
+import shutil
+
+
+sd_img_dirs = [
+    "outdir_txt2img_samples",
+    "outdir_img2img_samples",
+    "outdir_save",
+    "outdir_extras_samples",
+    "outdir_grids",
+    "outdir_img2img_grids",
+    "outdir_samples",
+    "outdir_txt2img_grids",
+]
+
+
+is_dev = os.getenv("APP_ENV") == "dev"
+is_nuitka = "__compiled__" in globals()
+is_pyinstaller_bundle = bool(getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'))
+is_exe_ver = is_nuitka or is_pyinstaller_bundle
+
+cwd = os.getcwd() if is_exe_ver else os.path.normpath(os.path.join(__file__, "../../../"))
+is_win = platform.system().lower().find("windows") != -1
+
+
+
+    
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv(os.path.join(cwd, ".env"))
+except Exception as e:
+    print(e)
+
+
+
+def backup_db_file(db_file_path):
+
+    if not os.path.exists(db_file_path):
+        return
+    max_backup_count = int(os.environ.get('IIB_DB_FILE_BACKUP_MAX', '8'))
+    if max_backup_count < 1:
+        return
+    backup_folder = os.path.join(cwd,'iib_db_backup')
+    current_time = datetime.now()
+    timestamp = current_time.strftime('%Y-%m-%d %H-%M-%S')
+    backup_filename = f"iib.db_{timestamp}"
+    os.makedirs(backup_folder, exist_ok=True)
+    backup_filepath = os.path.join(backup_folder, backup_filename)
+    shutil.copy2(db_file_path, backup_filepath)
+    backup_files = os.listdir(backup_folder)
+    pattern = r"iib\.db_(\d{4}-\d{2}-\d{2} \d{2}-\d{2}-\d{2})"
+    backup_files_with_time = [(f, re.search(pattern, f).group(1)) for f in backup_files if re.search(pattern, f)]
+    sorted_backup_files = sorted(backup_files_with_time, key=lambda x: datetime.strptime(x[1], '%Y-%m-%d %H-%M-%S'))
+
+    if len(sorted_backup_files) > max_backup_count:
+        files_to_remove_count = len(sorted_backup_files) - max_backup_count
+        for i in range(files_to_remove_count):
+            file_to_remove = os.path.join(backup_folder, sorted_backup_files[i][0])
+            os.remove(file_to_remove)
+            
+    print(f"\033[92mIIB Database file has been successfully backed up to the backup folder.\033[0m")
+
+def get_sd_webui_conf(**kwargs):
+    try:
+        from modules.shared import opts
+
+        return opts.data
+    except:
+        pass
+    try:
+        sd_conf_path = kwargs.get("sd_webui_config")
+        with codecs.open(sd_conf_path, "r", "utf-8") as f:
+            obj = json.loads(f.read())
+            if kwargs.get("sd_webui_path_relative_to_config"):
+                for dir in sd_img_dirs:
+                    if obj[dir] and not os.path.isabs(obj[dir]):
+                        obj[dir] = os.path.normpath(
+                            os.path.join(sd_conf_path, "../", obj[dir])
+                        )
+            return obj
+    except:
+        pass
+    return {}
+
+def normalize_paths(paths: List[str], base = cwd):
+    """
+    Normalize a list of paths, ensuring that each path is an absolute path with no redundant components.
+
+    Args:
+        paths (List[str]): A list of paths to be normalized.
+
+    Returns:
+        List[str]: A list of normalized paths.
+    """
+    res: List[str] = []
+    for path in paths:
+        # Skip empty or blank paths
+        if not path or len(path.strip()) == 0:
+            continue
+        # If the path is already an absolute path, use it as is
+        if os.path.isabs(path):
+            abs_path = path
+        # Otherwise, make the path absolute by joining it with the current working directory
+        else:
+            abs_path = os.path.join(base, path)
+        # If the absolute path exists, add it to the result after normalizing it
+        if os.path.exists(abs_path):
+            res.append(os.path.normpath(abs_path))
+    return res
+
+def to_abs_path(path):
+    if not os.path.isabs(path):
+        path = os.path.join(os.getcwd(), path)
+    return os.path.normpath(path)
+
+
+def get_valid_img_dirs(
+    conf,
+    keys=sd_img_dirs,
+):
+    # 获取配置项
+    paths = [conf.get(key) for key in keys]
+
+    # 判断路径是否有效并转为绝对路径
+    abs_paths = []
+    for path in paths:
+        if not path or len(path.strip()) == 0:
+            continue
+        if os.path.isabs(path):  # 已经是绝对路径
+            abs_path = path
+        else:  # 转为绝对路径
+            abs_path = os.path.join(os.getcwd(), path)
+        if os.path.exists(abs_path):  # 判断路径是否存在
+            abs_paths.append(os.path.normpath(abs_path))
+
+    return abs_paths
+
+
+def human_readable_size(size_bytes):
+    """
+    Converts bytes to a human-readable format.
+    """
+    # define the size units
+    units = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    # calculate the logarithm of the input value with base 1024
+    size = int(size_bytes)
+    if size == 0:
+        return "0B"
+    i = 0
+    while size >= 1024 and i < len(units) - 1:
+        size /= 1024
+        i += 1
+    # round the result to two decimal points and return as a string
+    return "{:.2f} {}".format(size, units[i])
+
+
+def get_windows_drives():
+    drives = []
+    bitmask = ctypes.windll.kernel32.GetLogicalDrives()
+    for letter in range(65, 91):
+        if bitmask & 1:
+            drive_name = chr(letter) + ":/"
+            drives.append(drive_name)
+        bitmask >>= 1
+    return drives
+
+
+pattern = re.compile(r"(\d+\.?\d*)([KMGT]?B)", re.IGNORECASE)
+
+
+def convert_to_bytes(file_size_str):
+    match = re.match(pattern, file_size_str)
+    if match:
+        size_str, unit_str = match.groups()
+        size = float(size_str)
+        unit = unit_str.upper()
+        if unit == "KB":
+            size *= 1024
+        elif unit == "MB":
+            size *= 1024**2
+        elif unit == "GB":
+            size *= 1024**3
+        elif unit == "TB":
+            size *= 1024**4
+        return int(size)
+    else:
+        raise ValueError(f"Invalid file size string '{file_size_str}'")
+    
+def get_video_type(file_path):
+    video_extensions = ['.mp4', '.m4v', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.ts']
+    file_extension = file_path[file_path.rfind('.'):].lower()
+
+    if file_extension in video_extensions:
+        return file_extension[1:] 
+    else:
+        return None
+    
+def is_image_file(filename: str) -> bool:
+    if not isinstance(filename, str):
+        return False
+    
+    extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.avif', '.jpe']
+    extension = filename.split('.')[-1].lower()
+    return f".{extension}" in extensions
+
+def is_video_file(filename: str) -> bool:
+    return isinstance(get_video_type(filename), str)
+
+def is_valid_media_path(path):
+    """
+    判断给定的路径是否是图像文件
+    """
+    abs_path = os.path.abspath(path)  # 转为绝对路径
+    if not os.path.exists(abs_path):  # 判断路径是否存在
+        return False
+    if not os.path.isfile(abs_path):  # 判断是否是文件
+        return False
+    return is_image_file(abs_path) or is_video_file(abs_path)
+
+def is_media_file(file_path):
+    return is_image_file(file_path) or is_video_file(file_path)
+
+def create_zip_file(file_paths: List[str], zip_file_name: str, compress = False):
+    """
+    将文件打包成一个压缩包
+
+    Args:
+        file_paths: 文件路径的列表
+        zip_file_name: 压缩包的文件名
+
+    Returns:
+        无返回值
+    """
+    with zipfile.ZipFile(zip_file_name, 'w', zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED) as zip_file:
+        for file_path in file_paths:
+            if os.path.isfile(file_path):
+                zip_file.write(file_path, os.path.basename(file_path))
+            elif os.path.isdir(file_path):
+                for root, _, files in os.walk(file_path):
+                    for file in files:
+                        full_path = os.path.join(root, file)
+                        zip_file.write(full_path, os.path.relpath(full_path, file_path))
+
+def get_temp_path():
+    """获取跨平台的临时文件目录路径"""
+    temp_path = None
+    try:
+        # 尝试获取系统环境变量中的临时文件目录路径
+        temp_path = (
+            os.environ.get("TMPDIR") or os.environ.get("TMP") or os.environ.get("TEMP")
+        )
+    except Exception as e:
+        print("获取系统环境变量临时文件目录路径失败，错误信息：", e)
+
+    # 如果系统环境变量中没有设置临时文件目录路径，则使用 Python 的 tempfile 模块创建临时文件目录
+    if not temp_path:
+        try:
+            temp_path = tempfile.gettempdir()
+        except Exception as e:
+            print("使用 Python 的 tempfile 模块创建临时文件目录失败，错误信息：", e)
+
+    # 确保临时文件目录存在
+    if not os.path.exists(temp_path):
+        try:
+            os.makedirs(temp_path)
+        except Exception as e:
+            print("创建临时文件目录失败，错误信息：", e)
+
+    return temp_path
+
+
+_temp_path = get_temp_path()
+
+
+def get_cache_dir():
+    return os.getenv("IIB_CACHE_DIR") or _temp_path
+
+def get_secret_key_required():
+    try:
+        from modules.shared import cmd_opts
+        return bool(cmd_opts.gradio_auth)
+    except:        
+        return False
+
+is_secret_key_required = get_secret_key_required()
+
+def get_enable_access_control():
+    ctrl = os.getenv("IIB_ACCESS_CONTROL")
+    if ctrl == "enable":
+        return True
+    if ctrl == "disable":
+        return False
+    try:
+        from modules.shared import cmd_opts
+
+        return (
+            cmd_opts.share or cmd_opts.ngrok or cmd_opts.listen or cmd_opts.server_name
+        )
+    except:
+        pass
+    return False
+
+
+enable_access_control = get_enable_access_control()
+
+
+def get_locale():
+    import locale
+
+    env_lang = os.getenv("IIB_SERVER_LANG")
+    if env_lang in ["zh", "en"]:
+        return env_lang
+    lang, _ = locale.getdefaultlocale()
+    return "zh" if lang and lang.startswith("zh") else "en"
+
+
+locale = get_locale()
+
+
+def get_formatted_date(timestamp: float) -> str:
+    return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+
+
+def get_modified_date(folder_path: str):
+    return get_formatted_date(os.path.getmtime(folder_path))
+
+
+def get_created_date(folder_path: str):
+    return get_formatted_date(os.path.getctime(folder_path))
+
+is_st_birthtime_available = True
+
+def get_created_date_by_stat(stat: os.stat_result):
+    global is_st_birthtime_available
+    try:
+        if is_st_birthtime_available:
+            return get_formatted_date(stat.st_birthtime)
+        else:
+            return get_formatted_date(stat.st_ctime)
+    except Exception as e:
+        is_st_birthtime_available = False
+        return get_formatted_date(stat.st_ctime)
+    
+def birthtime_sort_key_fn(x):
+    stat = x.stat()
+    global is_st_birthtime_available
+    try:
+        if is_st_birthtime_available and hasattr(stat, "st_birthtime"):
+            return stat.st_birthtime
+        else:
+            return stat.st_ctime
+    except:
+        is_st_birthtime_available = False
+        return stat.st_ctime
+
+def unique_by(seq, key_func=lambda x: x):
+    seen = set()
+    return [x for x in seq if not (key := key_func(x)) in seen and not seen.add(key)]
+
+
+def find(lst, comparator):
+    return next((item for item in lst if comparator(item)), None)
+
+
+def findIndex(lst, comparator):
+    return next((i for i, item in enumerate(lst) if comparator(item)), -1)
+
+def unquote(text):
+    if len(text) == 0 or text[0] != '"' or text[-1] != '"':
+        return text
+
+    try:
+        return json.loads(text)
+    except Exception:
+        return text
+
+def get_img_geninfo_txt_path(path: str):
+    txt_path = re.sub(r"\.\w+$", ".txt", path)
+    if os.path.exists(txt_path):
+        return txt_path
+
+def is_img_created_by_comfyui(img: Image):
+    prompt = img.info.get('prompt')
+    return prompt and (img.info.get('workflow') or ("class_type" in prompt)) # ermanitu
+
+def is_img_created_by_comfyui_with_webui_gen_info(img: Image):
+    return is_img_created_by_comfyui(img) and img.info.get('parameters')
+
+def get_comfyui_exif_data(img: Image):
+    prompt = img.info.get('prompt')
+    if not prompt:
+        return {}
+    meta_key = '3'
+    data: Dict[str, any] = json.loads(prompt)
+    for i in data.keys():
+        try:
+            if data[i]["class_type"].startswith("KSampler"):
+                meta_key = i
+                break
+        except:
+            pass
+    meta = {}
+    KSampler_entry = data[meta_key]["inputs"]
+    #print(KSampler_entry) # for testing
+
+    # As a workaround to bypass parsing errors in the parser.
+    # https://github.com/jiw0220/stable-diffusion-image-metadata/blob/00b8d42d4d1a536862bba0b07c332bdebb2a0ce5/src/index.ts#L130
+    meta["Steps"] = KSampler_entry.get("steps", "Unknown")
+    meta["Sampler"] = KSampler_entry["sampler_name"]
+    meta["Model"] = data[KSampler_entry["model"][0]]["inputs"].get("ckpt_name")
+    meta["Source Identifier"] = "ComfyUI"
+    def get_text_from_clip(idx: str) :
+        inputs = data[idx]["inputs"]
+        text = inputs["text"] if "text" in inputs else inputs["t5xxl"]
+        if isinstance(text, list): # type:CLIPTextEncode (NSP) mode:Wildcards
+            text = data[text[0]]["inputs"]["text"]
+        return text.strip()
+    
+    in_node = data[str(KSampler_entry["positive"][0])]
+    if in_node["class_type"] != "FluxGuidance":
+        pos_prompt = get_text_from_clip(KSampler_entry["positive"][0])
+    else:
+        pos_prompt = get_text_from_clip(in_node["inputs"]["conditioning"][0])
+
+    neg_prompt = get_text_from_clip(KSampler_entry["negative"][0])
+    pos_prompt_arr = unique_by(parse_prompt(pos_prompt)["pos_prompt"])
+    return {
+        "meta": meta,
+        "pos_prompt": pos_prompt_arr,
+        "pos_prompt_raw": pos_prompt,
+        "neg_prompt_raw" : neg_prompt
+    }
+
+def comfyui_exif_data_to_str(data):
+    res = data["pos_prompt_raw"] + "\nNegative prompt: " + data["neg_prompt_raw"] + "\n"
+    meta_arr = []
+    for k,v in data["meta"].items():
+        meta_arr.append(f'{k}: {v}')
+    return res + ", ".join(meta_arr)
+
+def read_sd_webui_gen_info_from_image(image: Image, path="") -> str:
+    """
+    Reads metadata from an image file.
+
+    Args:
+        image (PIL.Image.Image): The image object to read metadata from.
+        path (str): Optional. The path to the image file. Used to look for a .txt file with additional metadata.
+
+    Returns:
+        str: The metadata as a string.
+    """
+    items = image.info or {}
+    geninfo = items.pop("parameters", None)
+    if "exif" in items:
+        exif = piexif.load(items["exif"])
+        exif_comment = (exif or {}).get("Exif", {}).get(piexif.ExifIFD.UserComment, b"")
+
+        try:
+            exif_comment = piexif.helper.UserComment.load(exif_comment)
+        except ValueError:
+            exif_comment = exif_comment.decode("utf8", errors="ignore")
+
+        if exif_comment:
+            items["exif comment"] = exif_comment
+            geninfo = exif_comment
+
+    if not geninfo and path:
+        try:
+            txt_path = get_img_geninfo_txt_path(path)
+            if txt_path:
+                with open(txt_path) as f:
+                    geninfo = f.read()
+        except Exception as e:
+            pass
+
+    return geninfo
+
+
+re_param_code = r'\s*([\w ]+):\s*("(?:\\"[^,]|\\"|\\|[^\"])+"|[^,]*)(?:,|$)'
+re_param = re.compile(re_param_code)
+re_imagesize = re.compile(r"^(\d+)x(\d+)$")
+re_lora_prompt = re.compile("<lora:([\w_\s.]+)(?::([\d.]+))+>", re.IGNORECASE)
+re_lora_extract = re.compile(r"([\w_\s.]+)(?:\d+)?")
+re_lyco_prompt = re.compile("<lyco:([\w_\s.]+):([\d.]+)>", re.IGNORECASE)
+re_parens = re.compile(r"[\\/\[\](){}]+")
+re_lora_white_symbol= re.compile(r">\s+")
+
+
+def lora_extract(lora: str):
+    """
+    提取yoshino yoshino(2a79aa5adc4a)
+    """
+    res = re_lora_extract.match(lora)
+    return res.group(1) if res else lora
+
+
+def parse_prompt(x: str):
+    x = re.sub(r'\sBREAK\s', ' , BREAK , ', x)
+    x = re.sub(re_lora_white_symbol, "> , ", x)
+    x = x.replace("，", ",").replace("-", " ").replace("_", " ")
+    x = re.sub(re_parens, "", x)
+    tag_list = [x.strip() for x in x.split(",")]
+    res = []
+    lora_list = []
+    lyco_list = []
+    for tag in tag_list:
+        if len(tag) == 0:
+            continue
+        idx_colon = tag.find(":")
+        if idx_colon != -1:
+            if re.search(re_lora_prompt, tag):
+                lora_res = re.search(re_lora_prompt, tag)
+                lora_list.append(
+                    {"name": lora_res.group(1), "value": float(lora_res.group(2))}
+                )
+            elif re.search(re_lyco_prompt, tag):
+                lyco_res = re.search(re_lyco_prompt, tag)
+                lyco_list.append(
+                    {"name": lyco_res.group(1), "value": float(lyco_res.group(2))}
+                )
+            else:
+                tag = tag[0:idx_colon]
+                if len(tag):
+                    res.append(tag.lower())
+        else:
+            res.append(tag.lower())
+    return {"pos_prompt": res, "lora": lora_list, "lyco": lyco_list}
+
+
+def parse_generation_parameters(x: str):
+    res = {}
+    prompt = ""
+    negative_prompt = ""
+    done_with_prompt = False
+    if not x:
+        return {"meta": {}, "pos_prompt": [], "lora": [], "lyco": []}
+    
+    *lines, lastline = x.strip().split("\n")
+    if len(re_param.findall(lastline)) < 3:
+        lines.append(lastline)
+        lastline = ""
+    if len(lines) == 1 and lines[0].startswith("Postprocess"):  # 把上面改成<2应该也可以，当时不敢动
+        lastline = lines[
+            0
+        ]  # 把Postprocess upscale by: 4, Postprocess upscaler: R-ESRGAN 4x+ Anime6B 推到res解析
+        lines = []
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if line.startswith("Negative prompt:"):
+            done_with_prompt = True
+            line = line[16:].strip()
+
+        if done_with_prompt:
+            negative_prompt += ("" if negative_prompt == "" else "\n") + line
+        else:
+            prompt += ("" if prompt == "" else "\n") + line
+
+    for k, v in re_param.findall(lastline):
+        try:
+            if len(v) == 0:
+                res[k] = v
+                continue
+            if v[0] == '"' and v[-1] == '"':
+                v = unquote(v)
+
+            m = re_imagesize.match(v)
+            if m is not None:
+                res[f"{k}-1"] = m.group(1)
+                res[f"{k}-2"] = m.group(2)
+            else:
+                res[k] = v
+        except Exception:
+            print(f"Error parsing \"{k}: {v}\"")
+            
+    prompt_parse_res = parse_prompt(prompt)
+    lora = prompt_parse_res["lora"]
+    for k in res:
+        k_s = str(k)
+        if k_s.startswith("AddNet Module") and str(res[k]).lower() == "lora":
+            model = res[k_s.replace("Module", "Model")]
+            value = res.get(k_s.replace("Module", "Weight A"), "1")
+            lora.append({"name": lora_extract(model), "value": float(value)})
+    return {
+        "meta": res,
+        "pos_prompt": unique_by(prompt_parse_res["pos_prompt"]),
+        "lora": unique_by(lora, lambda x: x["name"].lower()),
+        "lyco": unique_by(prompt_parse_res["lyco"], lambda x: x["name"].lower()),
+    }
+
+
+tags_translate: Dict[str, str] = {}
+try:
+    import codecs
+
+    with codecs.open(os.path.join(cwd, "tags-translate.csv"), "r", "utf-8") as tag:
+        tags_translate_str = tag.read()
+        for line in tags_translate_str.splitlines():
+            en, mapping = line.split(",")
+            tags_translate[en.strip()] = mapping.strip()
+except Exception as e:
+    pass
+
+
+def open_folder(folder_path, file_path=None):
+    folder = os.path.realpath(folder_path)
+    if file_path:
+        file = os.path.join(folder, file_path)
+        if os.name == "nt":
+            subprocess.run(["explorer", "/select,", file])
+        elif sys.platform == "darwin":
+            subprocess.run(["open", "-R", file])
+        elif os.name == "posix":
+            subprocess.run(["xdg-open", file])
+    else:
+        if os.name == "nt":
+            subprocess.run(["explorer", folder])
+        elif sys.platform == "darwin":
+            subprocess.run(["open", folder])
+        elif os.name == "posix":
+            subprocess.run(["xdg-open", folder])
+
+
+def open_file_with_default_app(file_path):
+    system = platform.system()
+    if system == 'Darwin':  # macOS
+        subprocess.call(['open', file_path])
+    elif system == 'Windows':  # Windows
+        subprocess.call(file_path, shell=True)
+    elif system == 'Linux':  # Linux
+        subprocess.call(['xdg-open', file_path])
+    else:
+        raise OSError(f'Unsupported operating system: {system}')
+    
+def omit(d, keys):
+    return {k: v for k, v in d.items() if k not in keys}
+
+
+def get_current_commit_hash():
+    try:
+        result = subprocess.run(['git', 'rev-parse', 'HEAD'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, cwd=cwd)
+        if result.returncode == 0:
+            return result.stdout.strip()
+        else:
+            return None
+    except Exception:
+        return None
+
+def get_current_tag():
+    try:
+        result = subprocess.run(['git', 'describe', '--tags', '--abbrev=0'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, cwd=cwd)
+        if result.returncode == 0:
+            return result.stdout.strip()
+        else:
+            return None
+    except Exception:
+        return None
+    
+    
+def replace_punctuation(input_string):
+    return input_string.replace(',', ' ').replace('\n', ' ')
+
+
+def case_insensitive_get(d, key, default=None):
+    for k, v in d.items():
+        if k.lower() == key.lower():
+            return v
+    return default
+
+def build_sd_webui_style_img_gen_info(prompt, negative_prompt = 'None', meta = {}):
+    res = f"{prompt}\nNegative prompt: {negative_prompt}\n"
+    for k, v in meta.items():
+        res += f"{k}: {v}, "
+    return res
+
+def map_dict_keys(value_dict, map_dict=None):
+    if map_dict is None:
+        return value_dict
+    else:
+        return {map_dict.get(key, key): value for key, value in value_dict.items()}
+    
+
+def get_file_info_by_path(fullpath: str, is_under_scanned_path = True):
+    stat = os.stat(fullpath)
+    date = get_formatted_date(stat.st_mtime)
+    name = os.path.basename(fullpath)
+    created_time = get_created_date_by_stat(stat)
+    if os.path.isfile(fullpath):
+        bytes = stat.st_size
+        size = human_readable_size(bytes)
+        return {
+                "type": "file",
+                "date": date,
+                "size": size,
+                "name": name,
+                "bytes": bytes,
+                "created_time": created_time,
+                "fullpath": fullpath,
+                "is_under_scanned_path": is_under_scanned_path,
+            }
+        
+    elif os.path.isdir(fullpath):
+        return {
+            "type": "dir",
+            "date": date,
+            "created_time": created_time,
+            "size": "-",
+            "name": name,
+            "is_under_scanned_path": is_under_scanned_path,
+            "fullpath": fullpath,
+        }
+    return {}
+
+
+def get_frame_at_second(video_path, second):
+    import av
+    with av.open(video_path) as container:
+        time_base = container.streams.video[0].time_base
+        frame_container_pts = round( second / time_base)
+        
+        container.seek(frame_container_pts, backward=True, stream=container.streams.video[0])
+        frame = next(container.decode(video=0))
+        return frame
+    
+def get_data_file_path(filename):
+    if hasattr(sys, '_MEIPASS'):
+        # Running in a PyInstaller bundle
+        base_path = os.path.join(sys._MEIPASS)
+    else:
+        # Running in a normal Python environment
+        base_path = os.path.join(os.path.dirname(__file__))
+    
+    return os.path.normpath(os.path.join(base_path, "../../", filename))

extensions/sd-webui-infinite-image-browsing/scripts/iib/video_cover_gen.py

@@ -0,0 +1,59 @@
+import hashlib
+import os
+from typing import List
+from scripts.iib.tool import get_formatted_date, get_cache_dir, is_video_file
+from concurrent.futures import ThreadPoolExecutor
+import time
+
+
+def generate_video_covers(dirs,verbose=False):
+  start_time = time.time()
+  import imageio.v3 as iio
+  
+  cache_base_dir = get_cache_dir()
+
+  def process_video(item):
+    if item.is_dir():
+      verbose and print(f"Processing directory: {item.path}")
+      for sub_item in os.scandir(item.path):
+        process_video(sub_item)
+      return
+    if not os.path.exists(item.path) or not is_video_file(item.path):
+      return
+
+    try:
+      path = os.path.normpath(item.path)
+      stat = item.stat()
+      t = get_formatted_date(stat.st_mtime)
+      hash_dir = hashlib.md5((path + t).encode("utf-8")).hexdigest()
+      cache_dir = os.path.join(cache_base_dir, "iib_cache", "video_cover", hash_dir)
+      cache_path = os.path.join(cache_dir, "cover.webp")
+
+      # 如果缓存文件存在，则直接返回该文件
+      if os.path.exists(cache_path):
+        print(f"Video cover already exists: {path}")
+        return
+
+      frame = iio.imread(
+        path,
+        index=16,
+        plugin="pyav",
+      )
+
+      os.makedirs(cache_dir, exist_ok=True)
+      iio.imwrite(cache_path, frame, extension=".webp")
+      verbose and print(f"Video cover generated: {path}")
+    except Exception as e:
+      print(f"Error generating video cover: {path}")
+      print(e)
+
+  with ThreadPoolExecutor() as executor:
+    for dir_path in dirs:
+      folder_listing: List[os.DirEntry] = os.scandir(dir_path)
+      for item in folder_listing:
+        executor.submit(process_video, item)
+
+  print("Video covers generated successfully.")
+  end_time = time.time()
+  execution_time = end_time - start_time
+  print(f"Execution time: {execution_time} seconds")

extensions/sd-webui-infinite-image-browsing/scripts/iib_setup.py

@@ -0,0 +1,86 @@
+from scripts.iib.api import infinite_image_browsing_api, send_img_path
+from modules import script_callbacks, generation_parameters_copypaste as send
+from scripts.iib.tool import locale
+from scripts.iib.tool import read_sd_webui_gen_info_from_image
+from PIL import Image
+from scripts.iib.logger import logger
+
+from fastapi import FastAPI
+import gradio as gr
+from modules.shared import cmd_opts
+
+"""
+api函数声明和启动分离方便另外一边被外部调用
+"""
+
+
+def on_ui_tabs():
+    
+    with gr.Blocks(analytics_enabled=False) as view:
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("", elem_id="iib_top")
+                gr.HTML("error", elem_id="infinite_image_browsing_container_wrapper")
+                # 以下是使用2个组件模拟粘贴过程
+                img = gr.Image(
+                    type="pil",
+                    elem_id="iib_hidden_img",
+                )
+
+                def on_img_change():
+                    send_img_path["value"] = ""  # 真正收到图片改变才允许放行
+                
+                img.change(on_img_change)
+
+                img_update_trigger = gr.Button(
+                    "button", elem_id="iib_hidden_img_update_trigger"
+                )
+
+                # 修改文本和图像，等待修改完成后前端触发粘贴按钮
+                # 有时在触发后收不到回调，可能是在解析params。txt时除了问题删除掉就行了
+                def img_update_func():
+                    try:
+                        path = send_img_path.get("value")
+                        # logger.info("img_update_func %s", path)
+                        img = Image.open(path)
+                        info = read_sd_webui_gen_info_from_image(img, path)
+                        return img, info
+                    except Exception as e:
+                        logger.error("img_update_func err %s",e)
+
+                img_file_info = gr.Textbox(elem_id="iib_hidden_img_file_info")
+                img_update_trigger.click(img_update_func, outputs=[img, img_file_info])
+                for tab in ["txt2img", "img2img", "inpaint", "extras"]:
+                    btn = gr.Button(f"Send to {tab}", elem_id=f"iib_hidden_tab_{tab}")
+                    # 注册粘贴
+                    send.register_paste_params_button(
+                        send.ParamBinding(
+                            paste_button=btn,
+                            tabname=tab,
+                            source_image_component=img,
+                            source_text_component=img_file_info,
+                        )
+                    )
+
+        return (
+            (
+                view,
+                "无边图像浏览" if locale == "zh" else "Infinite image browsing",
+                "infinite-image-browsing",
+            ),
+        )
+
+def on_app_started(_: gr.Blocks, app: FastAPI) -> None:
+    # 第一个参数是SD-WebUI传进来的gr.Blocks，但是不需要使用
+    DEFAULT_BASE = "/infinite_image_browsing"
+    fe_public_path = None
+    subpath = vars(cmd_opts).get("subpath")
+
+    if subpath:
+        base = "/" + subpath + "/" + DEFAULT_BASE
+        fe_public_path = base.replace('//', '/')
+    infinite_image_browsing_api(app, fe_public_path = fe_public_path)
+
+
+script_callbacks.on_ui_tabs(on_ui_tabs)
+script_callbacks.on_app_started(on_app_started)

extensions/sd-webui-infinite-image-browsing/style.css

@@ -0,0 +1,3 @@
+[id^="iib_hidden_"] {
+  display: none !important;
+}

extensions/sd-webui-infinite-image-browsing/vue/.eslintrc.cjs

@@ -0,0 +1,31 @@
+/* eslint-disable no-undef */
+
+// require('@rushstack/eslint-patch/modern-module-resolution')
+
+module.exports = {
+  ignorePatterns: [
+    'dist/',
+    // 其他忽略规则
+  ],
+  root: true,
+  extends: [
+    'plugin:vue/vue3-essential',
+    'eslint:recommended',
+    '@vue/eslint-config-typescript',
+  ],
+  parserOptions: {
+    ecmaVersion: 'latest'
+  },
+  rules: {
+    'vue/multi-word-component-names': ['error', { ignores: ['index', 'index.vue'] }],
+    'no-console': 'off',
+    'quote-props': ['error', 'as-needed'],
+    quotes: ['error', 'single'],
+    'no-debugger': process.env.NODE_ENV === 'production' ? 'warn' : 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    indent: 'off',
+    '@typescript-eslint/indent': ['error', 2]
+  }
+}

extensions/sd-webui-infinite-image-browsing/vue/.gitignore

@@ -0,0 +1,22 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

extensions/sd-webui-infinite-image-browsing/vue/.prettierrc.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/prettierrc",
+  "semi": false,
+  "tabWidth": 2,
+  "singleQuote": true,
+  "printWidth": 100,
+  "trailingComma": "none"
+}

extensions/sd-webui-infinite-image-browsing/vue/.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["Vue.volar", "Vue.vscode-typescript-vue-plugin"]
+}

extensions/sd-webui-infinite-image-browsing/vue/README.md

@@ -0,0 +1,47 @@
+# vue
+
+This template should help get you started developing with Vue 3 in Vite.
+
+## Recommended IDE Setup
+
+[VSCode](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur) + [TypeScript Vue Plugin (Volar)](https://marketplace.visualstudio.com/items?itemName=Vue.vscode-typescript-vue-plugin).
+
+## Type Support for `.vue` Imports in TS
+
+TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [TypeScript Vue Plugin (Volar)](https://marketplace.visualstudio.com/items?itemName=Vue.vscode-typescript-vue-plugin) to make the TypeScript language service aware of `.vue` types.
+
+If the standalone TypeScript plugin doesn't feel fast enough to you, Volar has also implemented a [Take Over Mode](https://github.com/johnsoncodehk/volar/discussions/471#discussioncomment-1361669) that is more performant. You can enable it by the following steps:
+
+1. Disable the built-in TypeScript Extension
+    1) Run `Extensions: Show Built-in Extensions` from VSCode's command palette
+    2) Find `TypeScript and JavaScript Language Features`, right click and select `Disable (Workspace)`
+2. Reload the VSCode window by running `Developer: Reload Window` from the command palette.
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vitejs.dev/config/).
+
+## Project Setup
+
+```sh
+yarn
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+yarn dev
+```
+
+
+### Compile and Minify for Production, Deliver to Production Mode Resources
+
+```sh
+yarn build
+```
+
+### Lint with [ESLint](https://eslint.org/)
+
+```sh
+yarn lint
+```

extensions/sd-webui-infinite-image-browsing/vue/build.ts

@@ -0,0 +1,27 @@
+import { execSync } from 'child_process'
+import { readFile, rm, writeFile } from 'fs/promises'
+import { exit } from 'process'
+
+const main = async () => {
+  try {
+    console.log(execSync('vue-tsc && vite build').toString('utf8'))
+  } catch (error: any) {
+    if (error.stdout && error.stderr) {
+      console.log(error.stdout.toString('utf8'))
+      console.error(error.stderr.toString('utf8'))
+      exit(2)
+    } else {
+      throw error
+    }
+  }
+  try {
+    await rm('../javascript/index.js')
+    // eslint-disable-next-line no-empty
+  } catch (error) {
+
+  }
+  const html = (await readFile('dist/index.html')).toString()
+  const js = (await readFile('index.tpl.js')).toString().replace('__built_html__', html)
+  await writeFile('../javascript/index.js', js)
+}
+main()

extensions/sd-webui-infinite-image-browsing/vue/components.d.ts

@@ -0,0 +1,57 @@
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// Generated by unplugin-vue-components
+// Read more: https://github.com/vuejs/core/pull/3399
+import '@vue/runtime-core'
+
+export {}
+
+declare module '@vue/runtime-core' {
+  export interface GlobalComponents {
+    AAlert: typeof import('ant-design-vue/es')['Alert']
+    ABadge: typeof import('ant-design-vue/es')['Badge']
+    ABreadcrumb: typeof import('ant-design-vue/es')['Breadcrumb']
+    ABreadcrumbItem: typeof import('ant-design-vue/es')['BreadcrumbItem']
+    AButton: typeof import('ant-design-vue/es')['Button']
+    ACheckbox: typeof import('ant-design-vue/es')['Checkbox']
+    ACol: typeof import('ant-design-vue/es')['Col']
+    ACollapse: typeof import('ant-design-vue/es')['Collapse']
+    ACollapsePanel: typeof import('ant-design-vue/es')['CollapsePanel']
+    ADrawer: typeof import('ant-design-vue/es')['Drawer']
+    ADropdown: typeof import('ant-design-vue/es')['Dropdown']
+    AForm: typeof import('ant-design-vue/es')['Form']
+    AFormItem: typeof import('ant-design-vue/es')['FormItem']
+    AImage: typeof import('ant-design-vue/es')['Image']
+    AInput: typeof import('ant-design-vue/es')['Input']
+    AInputGroup: typeof import('ant-design-vue/es')['InputGroup']
+    AInputNumber: typeof import('ant-design-vue/es')['InputNumber']
+    AMenu: typeof import('ant-design-vue/es')['Menu']
+    AMenuDivider: typeof import('ant-design-vue/es')['MenuDivider']
+    AMenuItem: typeof import('ant-design-vue/es')['MenuItem']
+    AModal: typeof import('ant-design-vue/es')['Modal']
+    ARadioButton: typeof import('ant-design-vue/es')['RadioButton']
+    ARadioGroup: typeof import('ant-design-vue/es')['RadioGroup']
+    ARow: typeof import('ant-design-vue/es')['Row']
+    ASelect: typeof import('ant-design-vue/es')['Select']
+    ASkeleton: typeof import('ant-design-vue/es')['Skeleton']
+    ASlider: typeof import('ant-design-vue/es')['Slider']
+    ASpin: typeof import('ant-design-vue/es')['Spin']
+    ASubMenu: typeof import('ant-design-vue/es')['SubMenu']
+    ASwitch: typeof import('ant-design-vue/es')['Switch']
+    ATabPane: typeof import('ant-design-vue/es')['TabPane']
+    ATabs: typeof import('ant-design-vue/es')['Tabs']
+    ATag: typeof import('ant-design-vue/es')['Tag']
+    ATextarea: typeof import('ant-design-vue/es')['Textarea']
+    ATooltip: typeof import('ant-design-vue/es')['Tooltip']
+    BaseFileListInfo: typeof import('./src/components/BaseFileListInfo.vue')['default']
+    ChangeIndicator: typeof import('./src/components/ChangeIndicator.vue')['default']
+    ContextMenu: typeof import('./src/components/ContextMenu.vue')['default']
+    FileItem: typeof import('./src/components/FileItem.vue')['default']
+    HistoryRecord: typeof import('./src/components/HistoryRecord.vue')['default']
+    MultiSelectKeep: typeof import('./src/components/MultiSelectKeep.vue')['default']
+    NumInput: typeof import('./src/components/numInput.vue')['default']
+    RouterLink: typeof import('vue-router')['RouterLink']
+    RouterView: typeof import('vue-router')['RouterView']
+  }
+}

extensions/sd-webui-infinite-image-browsing/vue/dist/assets/Checkbox-5fa7cbf6.js

@@ -0,0 +1 @@
+import{d as E,bx as $,r as f,m as M,_ as T,a as c,al as W,h as m,c as v,P as z}from"./index-5b5fdd56.js";var G=["prefixCls","name","id","type","disabled","readonly","tabindex","autofocus","value","required"],H={prefixCls:String,name:String,id:String,type:String,defaultChecked:{type:[Boolean,Number],default:void 0},checked:{type:[Boolean,Number],default:void 0},disabled:Boolean,tabindex:{type:[Number,String]},readonly:Boolean,autofocus:Boolean,value:z.any,required:Boolean};const L=E({compatConfig:{MODE:3},name:"Checkbox",inheritAttrs:!1,props:$(H,{prefixCls:"rc-checkbox",type:"checkbox",defaultChecked:!1}),emits:["click","change"],setup:function(a,d){var t=d.attrs,h=d.emit,x=d.expose,o=f(a.checked===void 0?a.defaultChecked:a.checked),i=f();M(function(){return a.checked},function(){o.value=a.checked}),x({focus:function(){var e;(e=i.value)===null||e===void 0||e.focus()},blur:function(){var e;(e=i.value)===null||e===void 0||e.blur()}});var l=f(),g=function(e){if(!a.disabled){a.checked===void 0&&(o.value=e.target.checked),e.shiftKey=l.value;var r={target:c(c({},a),{},{checked:e.target.checked}),stopPropagation:function(){e.stopPropagation()},preventDefault:function(){e.preventDefault()},nativeEvent:e};a.checked!==void 0&&(i.value.checked=!!a.checked),h("change",r),l.value=!1}},C=function(e){h("click",e),l.value=e.shiftKey};return function(){var n,e=a.prefixCls,r=a.name,s=a.id,p=a.type,b=a.disabled,K=a.readonly,P=a.tabindex,B=a.autofocus,S=a.value,N=a.required,_=T(a,G),q=t.class,D=t.onFocus,j=t.onBlur,w=t.onKeydown,A=t.onKeypress,F=t.onKeyup,y=c(c({},_),t),O=Object.keys(y).reduce(function(k,u){return(u.substr(0,5)==="aria-"||u.substr(0,5)==="data-"||u==="role")&&(k[u]=y[u]),k},{}),R=W(e,q,(n={},m(n,"".concat(e,"-checked"),o.value),m(n,"".concat(e,"-disabled"),b),n)),V=c(c({name:r,id:s,type:p,readonly:K,disabled:b,tabindex:P,class:"".concat(e,"-input"),checked:!!o.value,autofocus:B,value:S},O),{},{onChange:g,onClick:C,onFocus:D,onBlur:j,onKeydown:w,onKeypress:A,onKeyup:F,required:N});return v("span",{class:R},[v("input",c({ref:i},V),null),v("span",{class:"".concat(e,"-inner")},null)])}}});export{L as V};

extensions/sd-webui-infinite-image-browsing/vue/dist/assets/FileItem-b2542180.js

@@ -0,0 +1,3 @@
+var vt=Object.defineProperty;var mt=(i,t,e)=>t in i?vt(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e;var ee=(i,t,e)=>(mt(i,typeof t!="symbol"?t+"":t,e),e);import{d as X,u as Ye,E as V,al as qe,h as K,c as A,ao as yt,d1 as bt,r as j,bc as At,X as H,c$ as St,P as $e,c5 as kt,A as W,d2 as ce,L as ge,ak as ke,bf as It,cQ as _t,bW as Ct,d3 as wt,cB as Et,d4 as Tt,d5 as Ge,bw as Pt,d6 as ae,d7 as Ot,aF as Nt,d8 as Dt,B as $t,d9 as zt,n as pe,m as se,aP as Mt,q as Ze,$ as Ie,c3 as Xe,aH as Qt,da as et,db as Bt,N as Ft,v as Rt,aN as tt,aO as nt,ax as it,S as a,a0 as R,dc as Lt,dd as jt,de as Ht,b$ as Vt,df as xt,ar as Ut,T as h,aE as te,Y as S,a1 as k,a6 as J,c0 as ze,c1 as Jt,dg as Wt,a5 as rt,ae as Y,V as I,W as y,a2 as Q,aj as st,cW as Kt,cV as Yt,M as ot,U as u,Z as lt,cS as qt,dh as Me,ad as Gt,di as Zt,cT as Xt,cm as en,dj as tn,dk as de,dl as nn}from"./index-5b5fdd56.js";import{h as Qe,g as rn,i as sn}from"./functionalCallableComp-51195a3e.js";import{i as on}from"./_isIterateeCall-c830f443.js";import{D as G,a as ve}from"./index-b6f2a43c.js";/* empty css              */var ln=function(){return{prefixCls:String,checked:{type:Boolean,default:void 0},onChange:{type:Function},onClick:{type:Function},"onUpdate:checked":Function}},an=X({compatConfig:{MODE:3},name:"ACheckableTag",props:ln(),setup:function(t,e){var n=e.slots,r=e.emit,o=Ye("tag",t),p=o.prefixCls,d=function(E){var w=t.checked;r("update:checked",!w),r("change",!w),r("click",E)},v=V(function(){var b;return qe(p.value,(b={},K(b,"".concat(p.value,"-checkable"),!0),K(b,"".concat(p.value,"-checkable-checked"),t.checked),b))});return function(){var b;return A("span",{class:v.value,onClick:d},[(b=n.default)===null||b===void 0?void 0:b.call(n)])}}});const me=an;var un=new RegExp("^(".concat(yt.join("|"),")(-inverse)?$")),cn=new RegExp("^(".concat(bt.join("|"),")$")),dn=function(){return{prefixCls:String,color:{type:String},closable:{type:Boolean,default:!1},closeIcon:$e.any,visible:{type:Boolean,default:void 0},onClose:{type:Function},"onUpdate:visible":Function,icon:$e.any}},Z=X({compatConfig:{MODE:3},name:"ATag",props:dn(),slots:["closeIcon","icon"],setup:function(t,e){var n=e.slots,r=e.emit,o=e.attrs,p=Ye("tag",t),d=p.prefixCls,v=p.direction,b=j(!0);At(function(){t.visible!==void 0&&(b.value=t.visible)});var E=function(s){s.stopPropagation(),r("update:visible",!1),r("close",s),!s.defaultPrevented&&t.visible===void 0&&(b.value=!1)},w=V(function(){var l=t.color;return l?un.test(l)||cn.test(l):!1}),T=V(function(){var l;return qe(d.value,(l={},K(l,"".concat(d.value,"-").concat(t.color),w.value),K(l,"".concat(d.value,"-has-color"),t.color&&!w.value),K(l,"".concat(d.value,"-hidden"),!b.value),K(l,"".concat(d.value,"-rtl"),v.value==="rtl"),l))});return function(){var l,s,c,m=t.icon,D=m===void 0?(l=n.icon)===null||l===void 0?void 0:l.call(n):m,O=t.color,$=t.closeIcon,g=$===void 0?(s=n.closeIcon)===null||s===void 0?void 0:s.call(n):$,f=t.closable,C=f===void 0?!1:f,M=function(){return C?g?A("span",{class:"".concat(d.value,"-close-icon"),onClick:E},[g]):A(kt,{class:"".concat(d.value,"-close-icon"),onClick:E},null):null},F={backgroundColor:O&&!w.value?O:void 0},B=D||null,_=(c=n.default)===null||c===void 0?void 0:c.call(n),L=B?A(H,null,[B,A("span",null,[_])]):_,P="onClick"in o,z=A("span",{class:T.value,style:F},[L,M()]);return P?A(St,null,{default:function(){return[z]}}):z}}});Z.CheckableTag=me;Z.install=function(i){return i.component(Z.name,Z),i.component(me.name,me),i};const fn=Z;G.Button=ve;G.install=function(i){return i.component(G.name,G),i.component(ve.name,ve),i};var hn={icon:{tag:"svg",attrs:{viewBox:"64 64 896 896",focusable:"false"},children:[{tag:"path",attrs:{d:"M908.1 353.1l-253.9-36.9L540.7 86.1c-3.1-6.3-8.2-11.4-14.5-14.5-15.8-7.8-35-1.3-42.9 14.5L369.8 316.2l-253.9 36.9c-7 1-13.4 4.3-18.3 9.3a32.05 32.05 0 00.6 45.3l183.7 179.1-43.4 252.9a31.95 31.95 0 0046.4 33.7L512 754l227.1 119.4c6.2 3.3 13.4 4.4 20.3 3.2 17.4-3 29.1-19.5 26.1-36.9l-43.4-252.9 183.7-179.1c5-4.9 8.3-11.3 9.3-18.3 2.7-17.5-9.5-33.7-27-36.3z"}}]},name:"star",theme:"filled"};const gn=hn;function Be(i){for(var t=1;t<arguments.length;t++){var e=arguments[t]!=null?Object(arguments[t]):{},n=Object.keys(e);typeof Object.getOwnPropertySymbols=="function"&&(n=n.concat(Object.getOwnPropertySymbols(e).filter(function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),n.forEach(function(r){pn(i,r,e[r])})}return i}function pn(i,t,e){return t in i?Object.defineProperty(i,t,{value:e,enumerable:!0,configurable:!0,writable:!0}):i[t]=e,i}var _e=function(t,e){var n=Be({},t,e.attrs);return A(W,Be({},n,{icon:gn}),null)};_e.displayName="StarFilled";_e.inheritAttrs=!1;const at=_e;var vn={icon:{tag:"svg",attrs:{viewBox:"64 64 896 896",focusable:"false"},children:[{tag:"path",attrs:{d:"M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326zm1.8 562H232V136h302v216a42 42 0 0042 42h216v494z"}}]},name:"file",theme:"outlined"};const mn=vn;function Fe(i){for(var t=1;t<arguments.length;t++){var e=arguments[t]!=null?Object(arguments[t]):{},n=Object.keys(e);typeof Object.getOwnPropertySymbols=="function"&&(n=n.concat(Object.getOwnPropertySymbols(e).filter(function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),n.forEach(function(r){yn(i,r,e[r])})}return i}function yn(i,t,e){return t in i?Object.defineProperty(i,t,{value:e,enumerable:!0,configurable:!0,writable:!0}):i[t]=e,i}var Ce=function(t,e){var n=Fe({},t,e.attrs);return A(W,Fe({},n,{icon:mn}),null)};Ce.displayName="FileOutlined";Ce.inheritAttrs=!1;const bn=Ce;var An={icon:{tag:"svg",attrs:{viewBox:"64 64 896 896",focusable:"false"},children:[{tag:"path",attrs:{d:"M928 444H820V330.4c0-17.7-14.3-32-32-32H473L355.7 186.2a8.15 8.15 0 00-5.5-2.2H96c-17.7 0-32 14.3-32 32v592c0 17.7 14.3 32 32 32h698c13 0 24.8-7.9 29.7-20l134-332c1.5-3.8 2.3-7.9 2.3-12 0-17.7-14.3-32-32-32zM136 256h188.5l119.6 114.4H748V444H238c-13 0-24.8 7.9-29.7 20L136 643.2V256zm635.3 512H159l103.3-256h612.4L771.3 768z"}}]},name:"folder-open",theme:"outlined"};const Sn=An;function Re(i){for(var t=1;t<arguments.length;t++){var e=arguments[t]!=null?Object(arguments[t]):{},n=Object.keys(e);typeof Object.getOwnPropertySymbols=="function"&&(n=n.concat(Object.getOwnPropertySymbols(e).filter(function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),n.forEach(function(r){kn(i,r,e[r])})}return i}function kn(i,t,e){return t in i?Object.defineProperty(i,t,{value:e,enumerable:!0,configurable:!0,writable:!0}):i[t]=e,i}var we=function(t,e){var n=Re({},t,e.attrs);return A(W,Re({},n,{icon:Sn}),null)};we.displayName="FolderOpenOutlined";we.inheritAttrs=!1;const In=we;function _n(i){return i&&i.length?i[0]:void 0}var Cn=Math.ceil,wn=Math.max;function En(i,t,e,n){for(var r=-1,o=wn(Cn((t-i)/(e||1)),0),p=Array(o);o--;)p[n?o:++r]=i,i+=e;return p}function Tn(i){return function(t,e,n){return n&&typeof n!="number"&&on(t,e,n)&&(e=n=void 0),t=ce(t),e===void 0?(e=t,t=0):e=ce(e),n=n===void 0?t<e?1:-1:ce(n),En(t,e,n,i)}}var Pn=Tn();const On=Pn,Nn="data:image/png;base64,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",ne=new WeakMap;function Dn(i,t){return{useHookShareState:n=>{const r=Ct();ge(r),ne.has(r)||(ne.set(r,ke(i(r,n??(t==null?void 0:t())))),It(()=>{ne.delete(r)}));const o=ne.get(r);return ge(o),{state:o,toRefs(){return _t(o)}}}}}var $n={icon:{tag:"svg",attrs:{viewBox:"0 0 1024 1024",focusable:"false"},children:[{tag:"path",attrs:{d:"M715.8 493.5L335 165.1c-14.2-12.2-35-1.2-35 18.5v656.8c0 19.7 20.8 30.7 35 18.5l380.8-328.4c10.9-9.4 10.9-27.6 0-37z"}}]},name:"caret-right",theme:"outlined"};const zn=$n;function Le(i){for(var t=1;t<arguments.length;t++){var e=arguments[t]!=null?Object(arguments[t]):{},n=Object.keys(e);typeof Object.getOwnPropertySymbols=="function"&&(n=n.concat(Object.getOwnPropertySymbols(e).filter(function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),n.forEach(function(r){Mn(i,r,e[r])})}return i}function Mn(i,t,e){return t in i?Object.defineProperty(i,t,{value:e,enumerable:!0,configurable:!0,writable:!0}):i[t]=e,i}var Ee=function(t,e){var n=Le({},t,e.attrs);return A(W,Le({},n,{icon:zn}),null)};Ee.displayName="CaretRightOutlined";Ee.inheritAttrs=!1;const je=Ee;var Qn={icon:{tag:"svg",attrs:{viewBox:"64 64 896 896",focusable:"false"},children:[{tag:"path",attrs:{d:"M923 283.6a260.04 260.04 0 00-56.9-82.8 264.4 264.4 0 00-84-55.5A265.34 265.34 0 00679.7 125c-49.3 0-97.4 13.5-139.2 39-10 6.1-19.5 12.8-28.5 20.1-9-7.3-18.5-14-28.5-20.1-41.8-25.5-89.9-39-139.2-39-35.5 0-69.9 6.8-102.4 20.3-31.4 13-59.7 31.7-84 55.5a258.44 258.44 0 00-56.9 82.8c-13.9 32.3-21 66.6-21 101.9 0 33.3 6.8 68 20.3 103.3 11.3 29.5 27.5 60.1 48.2 91 32.8 48.9 77.9 99.9 133.9 151.6 92.8 85.7 184.7 144.9 188.6 147.3l23.7 15.2c10.5 6.7 24 6.7 34.5 0l23.7-15.2c3.9-2.5 95.7-61.6 188.6-147.3 56-51.7 101.1-102.7 133.9-151.6 20.7-30.9 37-61.5 48.2-91 13.5-35.3 20.3-70 20.3-103.3.1-35.3-7-69.6-20.9-101.9z"}}]},name:"heart",theme:"filled"};const Bn=Qn;function He(i){for(var t=1;t<arguments.length;t++){var e=arguments[t]!=null?Object(arguments[t]):{},n=Object.keys(e);typeof Object.getOwnPropertySymbols=="function"&&(n=n.concat(Object.getOwnPropertySymbols(e).filter(function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),n.forEach(function(r){Fn(i,r,e[r])})}return i}function Fn(i,t,e){return t in i?Object.defineProperty(i,t,{value:e,enumerable:!0,configurable:!0,writable:!0}):i[t]=e,i}var Te=function(t,e){var n=He({},t,e.attrs);return A(W,He({},n,{icon:Bn}),null)};Te.displayName="HeartFilled";Te.inheritAttrs=!1;const Rn=Te;var Ln={icon:{tag:"svg",attrs:{viewBox:"64 64 896 896",focusable:"false"},children:[{tag:"path",attrs:{d:"M923 283.6a260.04 260.04 0 00-56.9-82.8 264.4 264.4 0 00-84-55.5A265.34 265.34 0 00679.7 125c-49.3 0-97.4 13.5-139.2 39-10 6.1-19.5 12.8-28.5 20.1-9-7.3-18.5-14-28.5-20.1-41.8-25.5-89.9-39-139.2-39-35.5 0-69.9 6.8-102.4 20.3-31.4 13-59.7 31.7-84 55.5a258.44 258.44 0 00-56.9 82.8c-13.9 32.3-21 66.6-21 101.9 0 33.3 6.8 68 20.3 103.3 11.3 29.5 27.5 60.1 48.2 91 32.8 48.9 77.9 99.9 133.9 151.6 92.8 85.7 184.7 144.9 188.6 147.3l23.7 15.2c10.5 6.7 24 6.7 34.5 0l23.7-15.2c3.9-2.5 95.7-61.6 188.6-147.3 56-51.7 101.1-102.7 133.9-151.6 20.7-30.9 37-61.5 48.2-91 13.5-35.3 20.3-70 20.3-103.3.1-35.3-7-69.6-20.9-101.9zM512 814.8S156 586.7 156 385.5C156 283.6 240.3 201 344.3 201c73.1 0 136.5 40.8 167.7 100.4C543.2 241.8 606.6 201 679.7 201c104 0 188.3 82.6 188.3 184.5 0 201.2-356 429.3-356 429.3z"}}]},name:"heart",theme:"outlined"};const jn=Ln;function Ve(i){for(var t=1;t<arguments.length;t++){var e=arguments[t]!=null?Object(arguments[t]):{},n=Object.keys(e);typeof Object.getOwnPropertySymbols=="function"&&(n=n.concat(Object.getOwnPropertySymbols(e).filter(function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),n.forEach(function(r){Hn(i,r,e[r])})}return i}function Hn(i,t,e){return t in i?Object.defineProperty(i,t,{value:e,enumerable:!0,configurable:!0,writable:!0}):i[t]=e,i}var Pe=function(t,e){var n=Ve({},t,e.attrs);return A(W,Ve({},n,{icon:jn}),null)};Pe.displayName="HeartOutlined";Pe.inheritAttrs=!1;const Vn=Pe;var xn={icon:{tag:"svg",attrs:{viewBox:"64 64 896 896",focusable:"false"},children:[{tag:"path",attrs:{d:"M908.1 353.1l-253.9-36.9L540.7 86.1c-3.1-6.3-8.2-11.4-14.5-14.5-15.8-7.8-35-1.3-42.9 14.5L369.8 316.2l-253.9 36.9c-7 1-13.4 4.3-18.3 9.3a32.05 32.05 0 00.6 45.3l183.7 179.1-43.4 252.9a31.95 31.95 0 0046.4 33.7L512 754l227.1 119.4c6.2 3.3 13.4 4.4 20.3 3.2 17.4-3 29.1-19.5 26.1-36.9l-43.4-252.9 183.7-179.1c5-4.9 8.3-11.3 9.3-18.3 2.7-17.5-9.5-33.7-27-36.3zM664.8 561.6l36.1 210.3L512 672.7 323.1 772l36.1-210.3-152.8-149L417.6 382 512 190.7 606.4 382l211.2 30.7-152.8 148.9z"}}]},name:"star",theme:"outlined"};const Un=xn;function xe(i){for(var t=1;t<arguments.length;t++){var e=arguments[t]!=null?Object(arguments[t]):{},n=Object.keys(e);typeof Object.getOwnPropertySymbols=="function"&&(n=n.concat(Object.getOwnPropertySymbols(e).filter(function(r){return Object.getOwnPropertyDescriptor(e,r).enumerable}))),n.forEach(function(r){Jn(i,r,e[r])})}return i}function Jn(i,t,e){return t in i?Object.defineProperty(i,t,{value:e,enumerable:!0,configurable:!0,writable:!0}):i[t]=e,i}var Oe=function(t,e){var n=xe({},t,e.attrs);return A(W,xe({},n,{icon:Un}),null)};Oe.displayName="StarOutlined";Oe.inheritAttrs=!1;const ut=Oe,Wn="/infinite_image_browsing/fe-static/assets/play-68f5544d.svg",Kn=wt("useBatchDownloadStore",()=>{const i=j([]);return{selectdFiles:i,addFiles:e=>{i.value=Et([...i.value,...e])}}});class oe{constructor(t,e=Tt.CREATED_TIME_DESC){ee(this,"root");ee(this,"execQueue",[]);ee(this,"walkerInitPromsie");this.entryPath=t,this.sortMethod=e,this.root={children:[],info:{name:this.entryPath,size:"-",bytes:0,created_time:"",is_under_scanned_path:!0,date:"",type:"dir",fullpath:this.entryPath}},this.walkerInitPromsie=new Promise(n=>{Qe([this.entryPath]).then(async r=>{this.root.info=r[this.entryPath],await this.fetchChildren(this.root),n()})})}reset(){return this.root.children=[],this.fetchChildren(this.root)}get images(){const t=e=>e.children.map(n=>{if(n.info.type==="dir")return t(n);if(ae(n.info.name))return n.info}).filter(n=>n).flat(1);return t(this.root)}get isCompleted(){return this.execQueue.length===0}async fetchChildren(t){const{files:e}=await rn(t.info.fullpath);return t.children=Ge(e,this.sortMethod).map(n=>({info:n,children:[]})),this.execQueue.shift(),this.execQueue.unshift(...t.children.filter(n=>n.info.type==="dir").map(n=>({fn:()=>this.fetchChildren(n),...n}))),t}async next(){await this.walkerInitPromsie;const t=_n(this.execQueue);if(!t)return null;const e=await t.fn();return this.execQueue=this.execQueue.slice(),this.root={...this.root},e}async isExpired(){const t=[this.root.info],e=r=>{for(const o of r.children)o.info.type==="dir"&&(t.push(o.info),e(o))};e(this.root);const n=await Qe(t.map(r=>r.fullpath));for(const r of t)if(!Pt(r,n[r.fullpath]))return!0;return!1}async seamlessRefresh(t,e=j(!1)){const n=performance.now(),r=new oe(this.entryPath,this.sortMethod);for(await r.walkerInitPromsie;!r.isCompleted&&r.images.length<t;){if(e.value)throw new Error("canceled");await r.next()}const o=performance.now();return console.log("seamlessRefresh currPos:",t,"Time taken:",(o-n).toFixed(0),"ms"),r}}var ct={exports:{}};/* NProgress, (c) 2013, 2014 Rico Sta. Cruz - http://ricostacruz.com/nprogress
+ * @license MIT */(function(i,t){(function(e,n){i.exports=n})(Ot,function(){var e={};e.version="0.3.5";var n=e.settings={minimum:.08,easing:"linear",positionUsing:"",speed:200,trickle:!0,trickleSpeed:200,showSpinner:!0,barSelector:'[role="bar"]',spinnerSelector:'[role="spinner"]',parent:"body",template:'<div class="bar" role="bar"><div class="peg"></div></div><div class="spinner" role="spinner"><div class="spinner-icon"></div></div>'};e.configure=function(s){var c,m;for(c in s)m=s[c],m!==void 0&&s.hasOwnProperty(c)&&(n[c]=m);return this},e.status=null,e.set=function(s){var c=e.isStarted();s=r(s,n.minimum,1),e.status=s===1?null:s;var m=e.render(!c),D=m.querySelector(n.barSelector),O=n.speed,$=n.easing;return m.offsetWidth,d(function(g){n.positionUsing===""&&(n.positionUsing=e.getPositioningCSS()),v(D,p(s,O,$)),s===1?(v(m,{transition:"none",opacity:1}),m.offsetWidth,setTimeout(function(){v(m,{transition:"all "+O+"ms linear",opacity:0}),setTimeout(function(){e.remove(),g()},O)},O)):setTimeout(g,O)}),this},e.isStarted=function(){return typeof e.status=="number"},e.start=function(){e.status||e.set(0);var s=function(){setTimeout(function(){e.status&&(e.trickle(),s())},n.trickleSpeed)};return n.trickle&&s(),this},e.done=function(s){return!s&&!e.status?this:e.inc(.3+.5*Math.random()).set(1)},e.inc=function(s){var c=e.status;return c?c>1?void 0:(typeof s!="number"&&(c>=0&&c<.2?s=.1:c>=.2&&c<.5?s=.04:c>=.5&&c<.8?s=.02:c>=.8&&c<.99?s=.005:s=0),c=r(c+s,0,.994),e.set(c)):e.start()},e.trickle=function(){return e.inc()},function(){var s=0,c=0;e.promise=function(m){return!m||m.state()==="resolved"?this:(c===0&&e.start(),s++,c++,m.always(function(){c--,c===0?(s=0,e.done()):e.set((s-c)/s)}),this)}}(),e.getElement=function(){var s=e.getParent();if(s){var c=Array.prototype.slice.call(s.querySelectorAll(".nprogress")).filter(function(m){return m.parentElement===s});if(c.length>0)return c[0]}return null},e.getParent=function(){if(n.parent instanceof HTMLElement)return n.parent;if(typeof n.parent=="string")return document.querySelector(n.parent)},e.render=function(s){if(e.isRendered())return e.getElement();E(document.documentElement,"nprogress-busy");var c=document.createElement("div");c.id="nprogress",c.className="nprogress",c.innerHTML=n.template;var m=c.querySelector(n.barSelector),D=s?"-100":o(e.status||0),O=e.getParent(),$;return v(m,{transition:"all 0 linear",transform:"translate3d("+D+"%,0,0)"}),n.showSpinner||($=c.querySelector(n.spinnerSelector),$&&l($)),O!=document.body&&E(O,"nprogress-custom-parent"),O.appendChild(c),c},e.remove=function(){e.status=null,w(document.documentElement,"nprogress-busy"),w(e.getParent(),"nprogress-custom-parent");var s=e.getElement();s&&l(s)},e.isRendered=function(){return!!e.getElement()},e.getPositioningCSS=function(){var s=document.body.style,c="WebkitTransform"in s?"Webkit":"MozTransform"in s?"Moz":"msTransform"in s?"ms":"OTransform"in s?"O":"";return c+"Perspective"in s?"translate3d":c+"Transform"in s?"translate":"margin"};function r(s,c,m){return s<c?c:s>m?m:s}function o(s){return(-1+s)*100}function p(s,c,m){var D;return n.positionUsing==="translate3d"?D={transform:"translate3d("+o(s)+"%,0,0)"}:n.positionUsing==="translate"?D={transform:"translate("+o(s)+"%,0)"}:D={"margin-left":o(s)+"%"},D.transition="all "+c+"ms "+m,D}var d=function(){var s=[];function c(){var m=s.shift();m&&m(c)}return function(m){s.push(m),s.length==1&&c()}}(),v=function(){var s=["Webkit","O","Moz","ms"],c={};function m(g){return g.replace(/^-ms-/,"ms-").replace(/-([\da-z])/gi,function(f,C){return C.toUpperCase()})}function D(g){var f=document.body.style;if(g in f)return g;for(var C=s.length,M=g.charAt(0).toUpperCase()+g.slice(1),F;C--;)if(F=s[C]+M,F in f)return F;return g}function O(g){return g=m(g),c[g]||(c[g]=D(g))}function $(g,f,C){f=O(f),g.style[f]=C}return function(g,f){var C=arguments,M,F;if(C.length==2)for(M in f)F=f[M],F!==void 0&&f.hasOwnProperty(M)&&$(g,M,F);else $(g,C[1],C[2])}}();function b(s,c){var m=typeof s=="string"?s:T(s);return m.indexOf(" "+c+" ")>=0}function E(s,c){var m=T(s),D=m+c;b(m,c)||(s.className=D.substring(1))}function w(s,c){var m=T(s),D;b(s,c)&&(D=m.replace(" "+c+" "," "),s.className=D.substring(1,D.length-1))}function T(s){return(" "+(s&&s.className||"")+" ").replace(/\s+/gi," ")}function l(s){s&&s.parentNode&&s.parentNode.removeChild(s)}return e})})(ct);var Yn=ct.exports;const gs=Nt(Yn);function ps({fetchNext:i}={}){const{scroller:t,sortedFiles:e,sortMethod:n,currLocation:r,stackViewEl:o,canLoadNext:p,previewIdx:d,props:v,walker:b,getViewableAreaFiles:E}=le().toRefs(),{state:w}=le(),T=j(!1),l=j(q.defaultGridCellWidth),s=V(()=>l.value+16),c=44,{width:m}=Dt(o),D=V(()=>~~(m.value/s.value)),O=ke(new Map),$=V(()=>{const B=s.value;return{first:B+(l.value<=160?0:c),second:B}}),g=j(!1),f=async()=>{var B;if(!(g.value||v.value.mode!=="walk"||!p.value))try{g.value=!0,await((B=b.value)==null?void 0:B.next())}finally{g.value=!1}},C=async(B=!1)=>{const _=t.value,L=()=>B?d.value:(_==null?void 0:_.$_endIndex)??0,P=()=>{const z=e.value.length,x=50;return z?i?L()>z-x:L()>z-x&&p.value:!0};for(;P();){await Ze(30);const z=await(i??f)();if(typeof z=="boolean"&&!z)return}};w.useEventListen("loadNextDir",$t(async(B=!1)=>{await C(B),v.value.mode==="walk"&&M()})),w.useEventListen("viewableAreaFilesChange",()=>{const B=E.value(),_=B.filter(P=>P.is_under_scanned_path&&ae(P.name)).map(P=>P.fullpath);qn.fetchImageTags(_);const L=B.filter(P=>P.is_under_scanned_path&&P.type==="dir"&&!O.has(P.fullpath)).map(P=>P.fullpath);L.length&&zt(L).then(P=>{for(const z in P)if(Object.prototype.hasOwnProperty.call(P,z)){const x=P[z];O.set(z,x)}})}),w.useEventListen("refresh",async()=>{w.eventEmitter.emit("viewableAreaFilesChange")});const M=pe(()=>w.eventEmitter.emit("viewableAreaFilesChange"),300);se(r,M);const F=pe(async()=>{await C(),M()},150);return{gridItems:D,sortedFiles:e,sortMethodConv:Mt,moreActionsDropdownShow:T,gridSize:s,sortMethod:n,onScroll:F,loadNextDir:f,loadNextDirLoading:g,canLoadNext:p,itemSize:$,cellWidth:l,dirCoverCache:O}}const vs=new Map,q=Ie(),ms=Kn(),qn=Xe(),ys=Qt(),bs=new BroadcastChannel("iib-image-transfer-bus"),{eventEmitter:As,useEventListen:Ss}=et(),{useHookShareState:le}=Dn((i,{images:t})=>{const e=j({tabIdx:-1,paneIdx:-1}),n=V(()=>Ft(r.value)),r=j([]),o=V(()=>{var f;return r.value.map(C=>C.curr).slice((f=q.conf)!=null&&f.is_win&&e.value.mode!=="scanned-fixed"?1:0)}),p=V(()=>Rt(...o.value)),d=V(()=>{var f,C;return e.value.mode==="scanned-fixed"?((C=(f=r.value)==null?void 0:f[0])==null?void 0:C.curr)??"":e.value.mode==="walk"?e.value.path??"":r.value.length===1?"/":p.value}),v=j(q.defaultSortingMethod),b=j(e.value.mode=="walk"?new oe(e.value.path,v.value):void 0);se([()=>e.value.mode,()=>e.value.path,v],async([f,C,M])=>{var F;f==="walk"?(b.value=new oe(C,M),r.value=[{files:[],curr:C}],await Ze(),await((F=b.value)==null?void 0:F.reset()),$.eventEmitter.emit("loadNextDir")):b.value=void 0});const E=ke(new Set);se(n,()=>E.clear());const w=V(()=>{var F;if(t.value)return t.value;if(b.value)return b.value.images.filter(B=>!E.has(B.fullpath));if(!n.value)return[];const f=((F=n.value)==null?void 0:F.files)??[],C=v.value;return Ge((B=>q.onlyFoldersAndImages?B.filter(_=>_.type==="dir"||ae(_.name)):B)(f),C).filter(B=>!E.has(B.fullpath))}),T=j([]),l=j(-1),s=V(()=>b.value?!b.value.isCompleted:!1),c=j(!1),m=j(!1),D=j(),O=()=>{var f,C,M;return(M=(C=(f=q.tabList)==null?void 0:f[e.value.tabIdx])==null?void 0:C.panes)==null?void 0:M[e.value.paneIdx]},$=et();$.useEventListen("selectAll",()=>{console.log(`select all 0 -> ${w.value.length}`),T.value=On(0,w.value.length)});const g=()=>{const f=D.value;if(f){const C=Math.max(f.$_startIndex-10,0);return w.value.slice(C,f.$_endIndex+10)}return[]};return{previewing:m,spinning:c,canLoadNext:s,multiSelectedIdxs:T,previewIdx:l,basePath:o,currLocation:d,currPage:n,stack:r,sortMethod:v,sortedFiles:w,scroller:D,stackViewEl:j(),props:e,getPane:O,walker:b,deletedFiles:E,getViewableAreaFiles:g,...$}},()=>({images:j()}));function ks(){const{eventEmitter:i,multiSelectedIdxs:t,sortedFiles:e}=le().toRefs();return{onSelectAll:()=>i.value.emit("selectAll"),onReverseSelect:()=>{t.value=e.value.map((p,d)=>d).filter(p=>!t.value.includes(p))},onClearAllSelected:()=>{t.value=[]}}}const Is=()=>{const{stackViewEl:i}=le().toRefs(),t=j(-1);return Bt(i,e=>{var r;let n=e.target;for(;n.parentElement;)if(n=n.parentElement,n.tagName.toLowerCase()==="li"&&n.classList.contains("file-item-trigger")){const o=(r=n.dataset)==null?void 0:r.idx;o&&Number.isSafeInteger(+o)&&(t.value=+o);return}}),{showMenuIdx:t}};function Gn(){var i=window.navigator.userAgent,t=i.indexOf("MSIE ");if(t>0)return parseInt(i.substring(t+5,i.indexOf(".",t)),10);var e=i.indexOf("Trident/");if(e>0){var n=i.indexOf("rv:");return parseInt(i.substring(n+3,i.indexOf(".",n)),10)}var r=i.indexOf("Edge/");return r>0?parseInt(i.substring(r+5,i.indexOf(".",r)),10):-1}let ie;function ye(){ye.init||(ye.init=!0,ie=Gn()!==-1)}var ue={name:"ResizeObserver",props:{emitOnMount:{type:Boolean,default:!1},ignoreWidth:{type:Boolean,default:!1},ignoreHeight:{type:Boolean,default:!1}},emits:["notify"],mounted(){ye(),it(()=>{this._w=this.$el.offsetWidth,this._h=this.$el.offsetHeight,this.emitOnMount&&this.emitSize()});const i=document.createElement("object");this._resizeObject=i,i.setAttribute("aria-hidden","true"),i.setAttribute("tabindex",-1),i.onload=this.addResizeHandlers,i.type="text/html",ie&&this.$el.appendChild(i),i.data="about:blank",ie||this.$el.appendChild(i)},beforeUnmount(){this.removeResizeHandlers()},methods:{compareAndNotify(){(!this.ignoreWidth&&this._w!==this.$el.offsetWidth||!this.ignoreHeight&&this._h!==this.$el.offsetHeight)&&(this._w=this.$el.offsetWidth,this._h=this.$el.offsetHeight,this.emitSize())},emitSize(){this.$emit("notify",{width:this._w,height:this._h})},addResizeHandlers(){this._resizeObject.contentDocument.defaultView.addEventListener("resize",this.compareAndNotify),this.compareAndNotify()},removeResizeHandlers(){this._resizeObject&&this._resizeObject.onload&&(!ie&&this._resizeObject.contentDocument&&this._resizeObject.contentDocument.defaultView.removeEventListener("resize",this.compareAndNotify),this.$el.removeChild(this._resizeObject),this._resizeObject.onload=null,this._resizeObject=null)}}};const Zn=Lt();tt("data-v-b329ee4c");const Xn={class:"resize-observer",tabindex:"-1"};nt();const ei=Zn((i,t,e,n,r,o)=>(a(),R("div",Xn)));ue.render=ei;ue.__scopeId="data-v-b329ee4c";ue.__file="src/components/ResizeObserver.vue";function re(i){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?re=function(t){return typeof t}:re=function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},re(i)}function ti(i,t){if(!(i instanceof t))throw new TypeError("Cannot call a class as a function")}function Ue(i,t){for(var e=0;e<t.length;e++){var n=t[e];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(i,n.key,n)}}function ni(i,t,e){return t&&Ue(i.prototype,t),e&&Ue(i,e),i}function Je(i){return ii(i)||ri(i)||si(i)||oi()}function ii(i){if(Array.isArray(i))return be(i)}function ri(i){if(typeof Symbol<"u"&&Symbol.iterator in Object(i))return Array.from(i)}function si(i,t){if(i){if(typeof i=="string")return be(i,t);var e=Object.prototype.toString.call(i).slice(8,-1);if(e==="Object"&&i.constructor&&(e=i.constructor.name),e==="Map"||e==="Set")return Array.from(i);if(e==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e))return be(i,t)}}function be(i,t){(t==null||t>i.length)&&(t=i.length);for(var e=0,n=new Array(t);e<t;e++)n[e]=i[e];return n}function oi(){throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function li(i){var t;return typeof i=="function"?t={callback:i}:t=i,t}function ai(i,t){var e=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},n,r,o,p=function(v){for(var b=arguments.length,E=new Array(b>1?b-1:0),w=1;w<b;w++)E[w-1]=arguments[w];if(o=E,!(n&&v===r)){var T=e.leading;typeof T=="function"&&(T=T(v,r)),(!n||v!==r)&&T&&i.apply(void 0,[v].concat(Je(o))),r=v,clearTimeout(n),n=setTimeout(function(){i.apply(void 0,[v].concat(Je(o))),n=0},t)}};return p._clear=function(){clearTimeout(n),n=null},p}function dt(i,t){if(i===t)return!0;if(re(i)==="object"){for(var e in i)if(!dt(i[e],t[e]))return!1;return!0}return!1}var ui=function(){function i(t,e,n){ti(this,i),this.el=t,this.observer=null,this.frozen=!1,this.createObserver(e,n)}return ni(i,[{key:"createObserver",value:function(e,n){var r=this;if(this.observer&&this.destroyObserver(),!this.frozen){if(this.options=li(e),this.callback=function(d,v){r.options.callback(d,v),d&&r.options.once&&(r.frozen=!0,r.destroyObserver())},this.callback&&this.options.throttle){var o=this.options.throttleOptions||{},p=o.leading;this.callback=ai(this.callback,this.options.throttle,{leading:function(v){return p==="both"||p==="visible"&&v||p==="hidden"&&!v}})}this.oldResult=void 0,this.observer=new IntersectionObserver(function(d){var v=d[0];if(d.length>1){var b=d.find(function(w){return w.isIntersecting});b&&(v=b)}if(r.callback){var E=v.isIntersecting&&v.intersectionRatio>=r.threshold;if(E===r.oldResult)return;r.oldResult=E,r.callback(E,v)}},this.options.intersection),it(function(){r.observer&&r.observer.observe(r.el)})}}},{key:"destroyObserver",value:function(){this.observer&&(this.observer.disconnect(),this.observer=null),this.callback&&this.callback._clear&&(this.callback._clear(),this.callback=null)}},{key:"threshold",get:function(){return this.options.intersection&&typeof this.options.intersection.threshold=="number"?this.options.intersection.threshold:0}}]),i}();function ft(i,t,e){var n=t.value;if(n)if(typeof IntersectionObserver>"u")console.warn("[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill");else{var r=new ui(i,n,e);i._vue_visibilityState=r}}function ci(i,t,e){var n=t.value,r=t.oldValue;if(!dt(n,r)){var o=i._vue_visibilityState;if(!n){ht(i);return}o?o.createObserver(n,e):ft(i,{value:n},e)}}function ht(i){var t=i._vue_visibilityState;t&&(t.destroyObserver(),delete i._vue_visibilityState)}var di={beforeMount:ft,updated:ci,unmounted:ht},fi={itemsLimit:1e3},hi=/(auto|scroll)/;function gt(i,t){return i.parentNode===null?t:gt(i.parentNode,t.concat([i]))}var fe=function(t,e){return getComputedStyle(t,null).getPropertyValue(e)},gi=function(t){return fe(t,"overflow")+fe(t,"overflow-y")+fe(t,"overflow-x")},pi=function(t){return hi.test(gi(t))};function We(i){if(i instanceof HTMLElement||i instanceof SVGElement){for(var t=gt(i.parentNode,[]),e=0;e<t.length;e+=1)if(pi(t[e]))return t[e];return document.scrollingElement||document.documentElement}}function Ae(i){"@babel/helpers - typeof";return Ae=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(t){return typeof t}:function(t){return t&&typeof Symbol=="function"&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Ae(i)}var vi={items:{type:Array,required:!0},keyField:{type:String,default:"id"},direction:{type:String,default:"vertical",validator:function(t){return["vertical","horizontal"].includes(t)}},listTag:{type:String,default:"div"},itemTag:{type:String,default:"div"}};function mi(){return this.items.length&&Ae(this.items[0])!=="object"}var Se=!1;if(typeof window<"u"){Se=!1;try{var yi=Object.defineProperty({},"passive",{get:function(){Se=!0}});window.addEventListener("test",null,yi)}catch{}}let bi=0;var pt={name:"RecycleScroller",components:{ResizeObserver:ue},directives:{ObserveVisibility:di},props:{...vi,itemSize:{type:Number,default:null},gridItems:{type:Number,default:void 0},itemSecondarySize:{type:Number,default:void 0},minItemSize:{type:[Number,String],default:null},sizeField:{type:String,default:"size"},typeField:{type:String,default:"type"},buffer:{type:Number,default:200},pageMode:{type:Boolean,default:!1},prerender:{type:Number,default:0},emitUpdate:{type:Boolean,default:!1},updateInterval:{type:Number,default:0},skipHover:{type:Boolean,default:!1},listTag:{type:String,default:"div"},itemTag:{type:String,default:"div"},listClass:{type:[String,Object,Array],default:""},itemClass:{type:[String,Object,Array],default:""}},emits:["resize","visible","hidden","update","scroll-start","scroll-end"],data(){return{pool:[],totalSize:0,ready:!1,hoverKey:null}},computed:{sizes(){if(this.itemSize===null){const i={"-1":{accumulator:0}},t=this.items,e=this.sizeField,n=this.minItemSize;let r=1e4,o=0,p;for(let d=0,v=t.length;d<v;d++)p=t[d][e]||n,p<r&&(r=p),o+=p,i[d]={accumulator:o,size:p};return this.$_computedMinItemSize=r,i}return[]},simpleArray:mi,itemIndexByKey(){const{keyField:i,items:t}=this,e={};for(let n=0,r=t.length;n<r;n++)e[t[n][i]]=n;return e}},watch:{items(){this.updateVisibleItems(!0)},pageMode(){this.applyPageMode(),this.updateVisibleItems(!1)},sizes:{handler(){this.updateVisibleItems(!1)},deep:!0},gridItems(){this.updateVisibleItems(!0)},itemSecondarySize(){this.updateVisibleItems(!0)}},created(){this.$_startIndex=0,this.$_endIndex=0,this.$_views=new Map,this.$_unusedViews=new Map,this.$_scrollDirty=!1,this.$_lastUpdateScrollPosition=0,this.prerender&&(this.$_prerender=!0,this.updateVisibleItems(!1)),this.gridItems&&!this.itemSize&&console.error("[vue-recycle-scroller] You must provide an itemSize when using gridItems")},mounted(){this.applyPageMode(),this.$nextTick(()=>{this.$_prerender=!1,this.updateVisibleItems(!0),this.ready=!0})},activated(){const i=this.$_lastUpdateScrollPosition;typeof i=="number"&&this.$nextTick(()=>{this.scrollToPosition(i)})},beforeUnmount(){this.removeListeners()},methods:{addView(i,t,e,n,r){const o=jt({id:bi++,index:t,used:!0,key:n,type:r}),p=Ht({item:e,position:0,nr:o});return i.push(p),p},unuseView(i,t=!1){const e=this.$_unusedViews,n=i.nr.type;let r=e.get(n);r||(r=[],e.set(n,r)),r.push(i),t||(i.nr.used=!1,i.position=-9999)},handleResize(){this.$emit("resize"),this.ready&&this.updateVisibleItems(!1)},handleScroll(i){if(!this.$_scrollDirty){if(this.$_scrollDirty=!0,this.$_updateTimeout)return;const t=()=>requestAnimationFrame(()=>{this.$_scrollDirty=!1;const{continuous:e}=this.updateVisibleItems(!1,!0);e||(clearTimeout(this.$_refreshTimout),this.$_refreshTimout=setTimeout(this.handleScroll,this.updateInterval+100))});t(),this.updateInterval&&(this.$_updateTimeout=setTimeout(()=>{this.$_updateTimeout=0,this.$_scrollDirty&&t()},this.updateInterval))}},handleVisibilityChange(i,t){this.ready&&(i||t.boundingClientRect.width!==0||t.boundingClientRect.height!==0?(this.$emit("visible"),requestAnimationFrame(()=>{this.updateVisibleItems(!1)})):this.$emit("hidden"))},updateVisibleItems(i,t=!1){const e=this.itemSize,n=this.gridItems||1,r=this.itemSecondarySize||e,o=this.$_computedMinItemSize,p=this.typeField,d=this.simpleArray?null:this.keyField,v=this.items,b=v.length,E=this.sizes,w=this.$_views,T=this.$_unusedViews,l=this.pool,s=this.itemIndexByKey;let c,m,D,O,$;if(!b)c=m=O=$=D=0;else if(this.$_prerender)c=O=0,m=$=Math.min(this.prerender,v.length),D=null;else{const _=this.getScroll();if(t){let z=_.start-this.$_lastUpdateScrollPosition;if(z<0&&(z=-z),e===null&&z<o||z<e)return{continuous:!0}}this.$_lastUpdateScrollPosition=_.start;const L=this.buffer;_.start-=L,_.end+=L;let P=0;if(this.$refs.before&&(P=this.$refs.before.scrollHeight,_.start-=P),this.$refs.after){const z=this.$refs.after.scrollHeight;_.end+=z}if(e===null){let z,x=0,Ne=b-1,U=~~(b/2),De;do De=U,z=E[U].accumulator,z<_.start?x=U:U<b-1&&E[U+1].accumulator>_.start&&(Ne=U),U=~~((x+Ne)/2);while(U!==De);for(U<0&&(U=0),c=U,D=E[b-1].accumulator,m=U;m<b&&E[m].accumulator<_.end;m++);for(m===-1?m=v.length-1:(m++,m>b&&(m=b)),O=c;O<b&&P+E[O].accumulator<_.start;O++);for($=O;$<b&&P+E[$].accumulator<_.end;$++);}else{c=~~(_.start/e*n);const z=c%n;c-=z,m=Math.ceil(_.end/e*n),O=Math.max(0,Math.floor((_.start-P)/e*n)),$=Math.floor((_.end-P)/e*n),c<0&&(c=0),m>b&&(m=b),O<0&&(O=0),$>b&&($=b),D=Math.ceil(b/n)*e}}m-c>fi.itemsLimit&&this.itemsLimitError(),this.totalSize=D;let g;const f=c<=this.$_endIndex&&m>=this.$_startIndex;if(f)for(let _=0,L=l.length;_<L;_++)g=l[_],g.nr.used&&(i&&(g.nr.index=s[g.item[d]]),(g.nr.index==null||g.nr.index<c||g.nr.index>=m)&&this.unuseView(g));const C=f?null:new Map;let M,F,B;for(let _=c;_<m;_++){M=v[_];const L=d?M[d]:M;if(L==null)throw new Error(`Key is ${L} on item (keyField is '${d}')`);if(g=w.get(L),!e&&!E[_].size){g&&this.unuseView(g);continue}F=M[p];let P=T.get(F),z=!1;if(!g)f?P&&P.length?g=P.pop():g=this.addView(l,_,M,L,F):(B=C.get(F)||0,(!P||B>=P.length)&&(g=this.addView(l,_,M,L,F),this.unuseView(g,!0),P=T.get(F)),g=P[B],C.set(F,B+1)),w.delete(g.nr.key),g.nr.used=!0,g.nr.index=_,g.nr.key=L,g.nr.type=F,w.set(L,g),z=!0;else if(!g.nr.used&&(g.nr.used=!0,g.nr.index=_,z=!0,P)){const x=P.indexOf(g);x!==-1&&P.splice(x,1)}g.item=M,z&&(_===v.length-1&&this.$emit("scroll-end"),_===0&&this.$emit("scroll-start")),e===null?(g.position=E[_-1].accumulator,g.offset=0):(g.position=Math.floor(_/n)*e,g.offset=_%n*r)}return this.$_startIndex=c,this.$_endIndex=m,this.emitUpdate&&this.$emit("update",c,m,O,$),clearTimeout(this.$_sortTimer),this.$_sortTimer=setTimeout(this.sortViews,this.updateInterval+300),{continuous:f}},getListenerTarget(){let i=We(this.$el);return window.document&&(i===window.document.documentElement||i===window.document.body)&&(i=window),i},getScroll(){const{$el:i,direction:t}=this,e=t==="vertical";let n;if(this.pageMode){const r=i.getBoundingClientRect(),o=e?r.height:r.width;let p=-(e?r.top:r.left),d=e?window.innerHeight:window.innerWidth;p<0&&(d+=p,p=0),p+d>o&&(d=o-p),n={start:p,end:p+d}}else e?n={start:i.scrollTop,end:i.scrollTop+i.clientHeight}:n={start:i.scrollLeft,end:i.scrollLeft+i.clientWidth};return n},applyPageMode(){this.pageMode?this.addListeners():this.removeListeners()},addListeners(){this.listenerTarget=this.getListenerTarget(),this.listenerTarget.addEventListener("scroll",this.handleScroll,Se?{passive:!0}:!1),this.listenerTarget.addEventListener("resize",this.handleResize)},removeListeners(){this.listenerTarget&&(this.listenerTarget.removeEventListener("scroll",this.handleScroll),this.listenerTarget.removeEventListener("resize",this.handleResize),this.listenerTarget=null)},scrollToItem(i){let t;const e=this.gridItems||1;this.itemSize===null?t=i>0?this.sizes[i-1].accumulator:0:t=Math.floor(i/e)*this.itemSize,this.scrollToPosition(t)},scrollToPosition(i){const t=this.direction==="vertical"?{scroll:"scrollTop",start:"top"}:{scroll:"scrollLeft",start:"left"};let e,n,r;if(this.pageMode){const o=We(this.$el),p=o.tagName==="HTML"?0:o[t.scroll],d=o.getBoundingClientRect(),b=this.$el.getBoundingClientRect()[t.start]-d[t.start];e=o,n=t.scroll,r=i+p+b}else e=this.$el,n=t.scroll,r=i;e[n]=r},itemsLimitError(){throw setTimeout(()=>{console.log("It seems the scroller element isn't scrolling, so it tries to render all the items at once.","Scroller:",this.$el),console.log("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.")}),new Error("Rendered items limit reached")},sortViews(){this.pool.sort((i,t)=>i.nr.index-t.nr.index)}}};const Ai={key:0,ref:"before",class:"vue-recycle-scroller__slot"},Si={key:1,ref:"after",class:"vue-recycle-scroller__slot"};function ki(i,t,e,n,r,o){const p=Vt("ResizeObserver"),d=xt("observe-visibility");return Ut((a(),h("div",{class:Y(["vue-recycle-scroller",{ready:r.ready,"page-mode":e.pageMode,[`direction-${i.direction}`]:!0}]),onScrollPassive:t[0]||(t[0]=(...v)=>o.handleScroll&&o.handleScroll(...v))},[i.$slots.before?(a(),h("div",Ai,[te(i.$slots,"before")],512)):S("v-if",!0),(a(),R(ze(e.listTag),{ref:"wrapper",style:rt({[i.direction==="vertical"?"minHeight":"minWidth"]:r.totalSize+"px"}),class:Y(["vue-recycle-scroller__item-wrapper",e.listClass])},{default:k(()=>[(a(!0),h(H,null,J(r.pool,v=>(a(),R(ze(e.itemTag),Jt({key:v.nr.id,style:r.ready?{transform:`translate${i.direction==="vertical"?"Y":"X"}(${v.position}px) translate${i.direction==="vertical"?"X":"Y"}(${v.offset}px)`,width:e.gridItems?`${i.direction==="vertical"&&e.itemSecondarySize||e.itemSize}px`:void 0,height:e.gridItems?`${i.direction==="horizontal"&&e.itemSecondarySize||e.itemSize}px`:void 0}:null,class:["vue-recycle-scroller__item-view",[e.itemClass,{hover:!e.skipHover&&r.hoverKey===v.nr.key}]]},Wt(e.skipHover?{}:{mouseenter:()=>{r.hoverKey=v.nr.key},mouseleave:()=>{r.hoverKey=null}})),{default:k(()=>[te(i.$slots,"default",{item:v.item,index:v.nr.index,active:v.nr.used})]),_:2},1040,["style","class"]))),128)),te(i.$slots,"empty")]),_:3},8,["style","class"])),i.$slots.after?(a(),h("div",Si,[te(i.$slots,"after")],512)):S("v-if",!0),A(p,{onNotify:o.handleResize},null,8,["onNotify"])],34)),[[d,o.handleVisibilityChange]])}pt.render=ki;pt.__file="src/components/RecycleScroller.vue";const Ke=X({__name:"ContextMenu",props:{file:{},idx:{},selectedTag:{},isSelectedMutilFiles:{type:Boolean}},emits:["contextMenuClick"],setup(i,{emit:t}){const e=i,n=Ie(),r=V(()=>{var o;return(((o=n.conf)==null?void 0:o.all_custom_tags)??[]).reduce((p,d)=>[...p,{...d,selected:!!e.selectedTag.find(v=>v.id===d.id)}],[])});return(o,p)=>{const d=st,v=Kt,b=Yt,E=ot;return a(),R(E,{onClick:p[0]||(p[0]=w=>t("contextMenuClick",w,o.file,o.idx))},{default:k(()=>{var w;return[A(d,{key:"deleteFiles"},{default:k(()=>[I(y(o.$t("deleteSelected")),1)]),_:1}),A(d,{key:"openWithDefaultApp"},{default:k(()=>[I(y(o.$t("openWithDefaultApp")),1)]),_:1}),A(d,{key:"saveSelectedAsJson"},{default:k(()=>[I(y(o.$t("saveSelectedAsJson")),1)]),_:1}),o.file.type==="dir"?(a(),h(H,{key:0},[A(d,{key:"openInNewTab"},{default:k(()=>[I(y(o.$t("openInNewTab")),1)]),_:1}),A(d,{key:"openOnTheRight"},{default:k(()=>[I(y(o.$t("openOnTheRight")),1)]),_:1}),A(d,{key:"openWithWalkMode"},{default:k(()=>[I(y(o.$t("openWithWalkMode")),1)]),_:1})],64)):S("",!0),o.file.type==="file"?(a(),h(H,{key:1},[Q(ae)(o.file.name)?(a(),h(H,{key:0},[A(d,{key:"viewGenInfo"},{default:k(()=>[I(y(o.$t("viewGenerationInfo")),1)]),_:1}),A(v),((w=Q(n).conf)==null?void 0:w.launch_mode)!=="server"?(a(),h(H,{key:0},[A(d,{key:"send2txt2img"},{default:k(()=>[I(y(o.$t("sendToTxt2img")),1)]),_:1}),A(d,{key:"send2img2img"},{default:k(()=>[I(y(o.$t("sendToImg2img")),1)]),_:1}),A(d,{key:"send2inpaint"},{default:k(()=>[I(y(o.$t("sendToInpaint")),1)]),_:1}),A(d,{key:"send2extras"},{default:k(()=>[I(y(o.$t("sendToExtraFeatures")),1)]),_:1}),A(b,{key:"sendToThirdPartyExtension",title:o.$t("sendToThirdPartyExtension")},{default:k(()=>[A(d,{key:"send2controlnet-txt2img"},{default:k(()=>[I("ControlNet - "+y(o.$t("t2i")),1)]),_:1}),A(d,{key:"send2controlnet-img2img"},{default:k(()=>[I("ControlNet - "+y(o.$t("i2i")),1)]),_:1}),A(d,{key:"send2outpaint"},{default:k(()=>[I("openOutpaint")]),_:1})]),_:1},8,["title"])],64)):S("",!0),A(d,{key:"send2BatchDownload"},{default:k(()=>[I(y(o.$t("sendToBatchDownload")),1)]),_:1}),A(b,{key:"copy2target",title:o.$t("copyTo")},{default:k(()=>[(a(!0),h(H,null,J(Q(n).quickMovePaths,T=>(a(),R(d,{key:`copy-to-${T.dir}`},{default:k(()=>[I(y(T.zh),1)]),_:2},1024))),128))]),_:1},8,["title"]),A(b,{key:"move2target",title:o.$t("moveTo")},{default:k(()=>[(a(!0),h(H,null,J(Q(n).quickMovePaths,T=>(a(),R(d,{key:`move-to-${T.dir}`},{default:k(()=>[I(y(T.zh),1)]),_:2},1024))),128))]),_:1},8,["title"]),A(v),o.isSelectedMutilFiles?(a(),h(H,{key:1},[A(b,{key:"batch-add-tag",title:o.$t("batchAddTag")},{default:k(()=>[A(d,{key:"add-custom-tag"},{default:k(()=>[I("+ "+y(o.$t("addNewCustomTag")),1)]),_:1}),(a(!0),h(H,null,J(r.value,T=>(a(),R(d,{key:`batch-add-tag-${T.id}`},{default:k(()=>[I(y(T.name),1)]),_:2},1024))),128))]),_:1},8,["title"]),A(b,{key:"batch-remove-tag",title:o.$t("batchRemoveTag")},{default:k(()=>[(a(!0),h(H,null,J(r.value,T=>(a(),R(d,{key:`batch-remove-tag-${T.id}`},{default:k(()=>[I(y(T.name),1)]),_:2},1024))),128))]),_:1},8,["title"])],64)):(a(),R(b,{key:"toggle-tag",title:o.$t("toggleTag")},{default:k(()=>[A(d,{key:"add-custom-tag"},{default:k(()=>[I("+ "+y(o.$t("addNewCustomTag")),1)]),_:1}),(a(!0),h(H,null,J(r.value,T=>(a(),R(d,{key:`toggle-tag-${T.id}`},{default:k(()=>[I(y(T.name)+" ",1),T.selected?(a(),R(Q(at),{key:0})):(a(),R(Q(ut),{key:1}))]),_:2},1024))),128))]),_:1},8,["title"])),A(v),A(d,{key:"openFileLocationInNewTab"},{default:k(()=>[I(y(o.$t("openFileLocationInNewTab")),1)]),_:1}),A(d,{key:"openWithLocalFileBrowser"},{default:k(()=>[I(y(o.$t("openWithLocalFileBrowser")),1)]),_:1})],64)):S("",!0),A(v),A(d,{key:"rename"},{default:k(()=>[I(y(o.$t("rename")),1)]),_:1}),A(d,{key:"previewInNewWindow"},{default:k(()=>[I(y(o.$t("previewInNewWindow")),1)]),_:1}),A(d,{key:"download"},{default:k(()=>[I(y(o.$t("download")),1)]),_:1}),A(d,{key:"copyPreviewUrl"},{default:k(()=>[I(y(o.$t("copySourceFilePreviewLink")),1)]),_:1}),A(d,{key:"copyFilePath"},{default:k(()=>[I(y(o.$t("copyFilePath")),1)]),_:1})],64)):S("",!0)]}),_:1})}}}),N=i=>(tt("data-v-78cd67a3"),i=i(),nt(),i),Ii={class:"changeIndicatorWrapper"},_i={key:0,class:"changeIndicatorsLeft changeIndicators"},Ci={key:0,class:"promptChangeIndicator changeIndicator"},wi={key:1,class:"negpromptChangeIndicator changeIndicator"},Ei={key:2,class:"seedChangeIndicator changeIndicator"},Ti={key:3,class:"stepsChangeIndicator changeIndicator"},Pi={key:4,class:"cfgChangeIndicator changeIndicator"},Oi={key:5,class:"sizeChangeIndicator changeIndicator"},Ni={key:6,class:"modelChangeIndicator changeIndicator"},Di={key:7,class:"samplerChangeIndicator changeIndicator"},$i={key:8,class:"otherChangeIndicator changeIndicator"},zi={class:"hoverOverlay"},Mi=N(()=>u("strong",null,"This file",-1)),Qi=N(()=>u("br",null,null,-1)),Bi=N(()=>u("br",null,null,-1)),Fi={key:0},Ri=N(()=>u("td",null,[u("span",{class:"promptChangeIndicator"},"+ Prompt")],-1)),Li={key:1},ji=N(()=>u("td",null,[u("span",{class:"negpromptChangeIndicator"},"- Prompt")],-1)),Hi={key:2},Vi=N(()=>u("td",null,[u("span",{class:"seedChangeIndicator"},"Seed")],-1)),xi={key:3},Ui=N(()=>u("td",null,[u("span",{class:"stepsChangeIndicator"},"Steps")],-1)),Ji={key:4},Wi=N(()=>u("td",null,[u("span",{class:"cfgChangeIndicator"},"Cfg Scale")],-1)),Ki={key:5},Yi=N(()=>u("td",null,[u("span",{class:"sizeChangeIndicator"},"Size")],-1)),qi={key:6},Gi=N(()=>u("td",null,[u("span",{class:"modelChangeIndicator"},"Model")],-1)),Zi=N(()=>u("br",null,null,-1)),Xi={key:7},er=N(()=>u("td",null,[u("span",{class:"samplerChangeIndicator"},"Sampler")],-1)),tr=N(()=>u("br",null,null,-1)),nr=N(()=>u("br",null,null,-1)),ir={key:0},rr=N(()=>u("span",{class:"otherChangeIndicator"},"Other",-1)),sr=N(()=>u("br",null,null,-1)),or=N(()=>u("br",null,null,-1)),lr={key:1,class:"changeIndicatorsRight changeIndicators"},ar={key:0,class:"promptChangeIndicator changeIndicator"},ur={key:1,class:"negpromptChangeIndicator changeIndicator"},cr={key:2,class:"seedChangeIndicator changeIndicator"},dr={key:3,class:"stepsChangeIndicator changeIndicator"},fr={key:4,class:"cfgChangeIndicator changeIndicator"},hr={key:5,class:"sizeChangeIndicator changeIndicator"},gr={key:6,class:"modelChangeIndicator changeIndicator"},pr={key:7,class:"samplerChangeIndicator changeIndicator"},vr={key:8,class:"otherChangeIndicator changeIndicator"},mr={class:"hoverOverlay"},yr=N(()=>u("strong",null,"This file",-1)),br=N(()=>u("br",null,null,-1)),Ar=N(()=>u("br",null,null,-1)),Sr={key:0},kr=N(()=>u("td",null,[u("span",{class:"promptChangeIndicator"},"+ Prompt")],-1)),Ir={key:1},_r=N(()=>u("td",null,[u("span",{class:"negpromptChangeIndicator"},"- Prompt")],-1)),Cr={key:2},wr=N(()=>u("td",null,[u("span",{class:"seedChangeIndicator"},"Seed")],-1)),Er={key:3},Tr=N(()=>u("td",null,[u("span",{class:"stepsChangeIndicator"},"Steps")],-1)),Pr={key:4},Or=N(()=>u("td",null,[u("span",{class:"cfgChangeIndicator"},"Cfg Scale")],-1)),Nr={key:5},Dr=N(()=>u("td",null,[u("span",{class:"sizeChangeIndicator"},"Size")],-1)),$r={key:6},zr=N(()=>u("td",null,[u("span",{class:"modelChangeIndicator"},"Model")],-1)),Mr=N(()=>u("br",null,null,-1)),Qr={key:7},Br=N(()=>u("td",null,[u("span",{class:"samplerChangeIndicator"},"Sampler")],-1)),Fr=N(()=>u("br",null,null,-1)),Rr=N(()=>u("br",null,null,-1)),Lr={key:0},jr=N(()=>u("span",{class:"otherChangeIndicator"},"Other",-1)),Hr=N(()=>u("br",null,null,-1)),Vr=N(()=>u("br",null,null,-1)),xr=X({__name:"ChangeIndicator",props:{genDiffToPrevious:{},genDiffToNext:{},genInfo:{}},setup(i){function t(n){const r=["prompt","negativePrompt","seed","steps","cfgScale","size","Model","others"],o=Object.keys(n).filter(p=>!r.includes(p));return Object.fromEntries(o.map(p=>[p,n[p]]))}function e(n){return Object.keys(t(n)).length>0}return(n,r)=>(a(),h("div",Ii,[n.genDiffToPrevious.empty?S("",!0):(a(),h("div",_i,["prompt"in n.genDiffToPrevious.diff?(a(),h("div",Ci,"P+")):S("",!0),"negativePrompt"in n.genDiffToPrevious.diff?(a(),h("div",wi,"P-")):S("",!0),"seed"in n.genDiffToPrevious.diff?(a(),h("div",Ei,"Se")):S("",!0),"steps"in n.genDiffToPrevious.diff?(a(),h("div",Ti,"St")):S("",!0),"cfgScale"in n.genDiffToPrevious.diff?(a(),h("div",Pi,"Cf")):S("",!0),"size"in n.genDiffToPrevious.diff?(a(),h("div",Oi,"Si")):S("",!0),"Model"in n.genDiffToPrevious.diff?(a(),h("div",Ni,"Mo")):S("",!0),"Sampler"in n.genDiffToPrevious.diff?(a(),h("div",Di,"Sa")):S("",!0),e(n.genDiffToPrevious.diff)?(a(),h("div",$i,"Ot")):S("",!0)])),u("div",zi,[u("small",null,[A(Q(je)),Mi,I(" vs "+y(n.genDiffToPrevious.otherFile)+" ",1),Qi,Bi,u("table",null,["prompt"in n.genDiffToPrevious.diff?(a(),h("tr",Fi,[Ri,u("td",null,y(n.genDiffToPrevious.diff.prompt)+" tokens changed",1)])):S("",!0),"negativePrompt"in n.genDiffToPrevious.diff?(a(),h("tr",Li,[ji,u("td",null,y(n.genDiffToPrevious.diff.negativePrompt)+" tokens changed",1)])):S("",!0),"seed"in n.genDiffToPrevious.diff?(a(),h("tr",Hi,[Vi,u("td",null,[u("strong",null,y(n.genDiffToPrevious.diff.seed[0]),1),I(" vs "+y(n.genDiffToPrevious.diff.seed[1]),1)])])):S("",!0),"steps"in n.genDiffToPrevious.diff?(a(),h("tr",xi,[Ui,u("td",null,[u("strong",null,y(n.genDiffToPrevious.diff.steps[0]),1),I(" vs "+y(n.genDiffToPrevious.diff.steps[1]),1)])])):S("",!0),"cfgScale"in n.genDiffToPrevious.diff?(a(),h("tr",Ji,[Wi,u("td",null,[u("strong",null,y(n.genDiffToPrevious.diff.cfgScale[0]),1),I(" vs "+y(n.genDiffToPrevious.diff.cfgScale[1]),1)])])):S("",!0),"size"in n.genDiffToPrevious.diff?(a(),h("tr",Ki,[Yi,u("td",null,[u("strong",null,y(n.genDiffToPrevious.diff.size[0]),1),I(" vs "+y(n.genDiffToPrevious.diff.size[1]),1)])])):S("",!0),"Model"in n.genDiffToPrevious.diff?(a(),h("tr",qi,[Gi,u("td",null,[u("strong",null,y(n.genDiffToPrevious.diff.Model[0]),1),Zi,I(" vs "+y(n.genDiffToPrevious.diff.Model[1]),1)])])):S("",!0),"Sampler"in n.genDiffToPrevious.diff?(a(),h("tr",Xi,[er,u("td",null,[u("strong",null,y(n.genDiffToPrevious.diff.Sampler[0]),1),tr,I(" vs "+y(n.genDiffToPrevious.diff.Sampler[1]),1)])])):S("",!0)]),nr,e(n.genDiffToPrevious.diff)?(a(),h("div",ir,[rr,I(" props that changed:"),sr,or,u("ul",null,[(a(!0),h(H,null,J(t(n.genDiffToPrevious.diff),(o,p)=>(a(),h("li",null,y(p),1))),256))])])):S("",!0)])]),n.genDiffToNext.empty?S("",!0):(a(),h("div",lr,["prompt"in n.genDiffToNext.diff?(a(),h("div",ar,"P+")):S("",!0),"negativePrompt"in n.genDiffToNext.diff?(a(),h("div",ur,"P-")):S("",!0),"seed"in n.genDiffToNext.diff?(a(),h("div",cr,"Se")):S("",!0),"steps"in n.genDiffToNext.diff?(a(),h("div",dr,"St")):S("",!0),"cfgScale"in n.genDiffToNext.diff?(a(),h("div",fr,"Cf")):S("",!0),"size"in n.genDiffToNext.diff?(a(),h("div",hr,"Si")):S("",!0),"Model"in n.genDiffToNext.diff?(a(),h("div",gr,"Mo")):S("",!0),"Sampler"in n.genDiffToNext.diff?(a(),h("div",pr,"Sa")):S("",!0),e(n.genDiffToNext.diff)?(a(),h("div",vr,"Ot")):S("",!0)])),u("div",mr,[u("small",null,[A(Q(je)),yr,I(" vs "+y(n.genDiffToNext.otherFile)+" ",1),br,Ar,u("table",null,["prompt"in n.genDiffToNext.diff?(a(),h("tr",Sr,[kr,u("td",null,y(n.genDiffToNext.diff.prompt)+" tokens changed",1)])):S("",!0),"negativePrompt"in n.genDiffToNext.diff?(a(),h("tr",Ir,[_r,u("td",null,y(n.genDiffToNext.diff.negativePrompt)+" tokens changed",1)])):S("",!0),"seed"in n.genDiffToNext.diff?(a(),h("tr",Cr,[wr,u("td",null,[u("strong",null,y(n.genDiffToNext.diff.seed[0]),1),I(" vs "+y(n.genDiffToNext.diff.seed[1]),1)])])):S("",!0),"steps"in n.genDiffToNext.diff?(a(),h("tr",Er,[Tr,u("td",null,[u("strong",null,y(n.genDiffToNext.diff.steps[0]),1),I(" vs "+y(n.genDiffToNext.diff.steps[1]),1)])])):S("",!0),"cfgScale"in n.genDiffToNext.diff?(a(),h("tr",Pr,[Or,u("td",null,[u("strong",null,y(n.genDiffToNext.diff.cfgScale[0]),1),I(" vs "+y(n.genDiffToNext.diff.cfgScale[1]),1)])])):S("",!0),"size"in n.genDiffToNext.diff?(a(),h("tr",Nr,[Dr,u("td",null,[u("strong",null,y(n.genDiffToNext.diff.size[0]),1),I(" vs "+y(n.genDiffToNext.diff.size[1]),1)])])):S("",!0),"Model"in n.genDiffToNext.diff?(a(),h("tr",$r,[zr,u("td",null,[u("strong",null,y(n.genDiffToNext.diff.Model[0]),1),Mr,I(" vs "+y(n.genDiffToNext.diff.Model[1]),1)])])):S("",!0),"Sampler"in n.genDiffToNext.diff?(a(),h("tr",Qr,[Br,u("td",null,[u("strong",null,y(n.genDiffToNext.diff.Sampler[0]),1),Fr,I(" vs "+y(n.genDiffToNext.diff.Sampler[1]),1)])])):S("",!0)]),Rr,e(n.genDiffToNext.diff)?(a(),h("div",Lr,[jr,I(" props that changed:"),Hr,Vr,u("ul",null,[(a(!0),h(H,null,J(t(n.genDiffToNext.diff),(o,p)=>(a(),h("li",null,y(p),1))),256))])])):S("",!0)])])]))}});const Ur=lt(xr,[["__scopeId","data-v-78cd67a3"]]),Jr=["data-idx"],Wr={key:1,class:"more"},Kr={class:"float-btn-wrap"},Yr={key:1,class:"tags-container"},qr=["url"],Gr={class:"play-icon"},Zr=["src"],Xr={key:0,class:"tags-container"},es={key:4,class:"preview-icon-wrap"},ts={key:1,class:"dir-cover-container"},ns=["src"],is={key:5,class:"profile"},rs=["title"],ss={class:"basic-info"},os={style:{"margin-right":"4px"}},he=160,ls=X({__name:"FileItem",props:{file:{},idx:{},selected:{type:Boolean,default:!1},showMenuIdx:{},cellWidth:{},fullScreenPreviewImageUrl:{},enableRightClickMenu:{type:Boolean,default:!0},enableCloseIcon:{type:Boolean,default:!1},isSelectedMutilFiles:{type:Boolean},genInfo:{},enableChangeIndicator:{type:Boolean},extraTags:{},coverFiles:{},getGenDiff:{},getGenDiffWatchDep:{}},emits:["update:showMenuIdx","fileItemClick","dragstart","dragend","previewVisibleChange","contextMenuClick","close-icon-click"],setup(i,{emit:t}){const e=i;qt(l=>({"02c5ba15":l.$props.cellWidth+"px"}));const n=Ie(),r=Xe(),o=j(),p=j(),d=pe(()=>{const{getGenDiff:l,file:s,idx:c}=e;l&&(p.value=l(s.gen_info_obj,c,1,s),o.value=l(s.gen_info_obj,c,-1,s))},200+100*Math.random());se(()=>{var l;return(l=e.getGenDiffWatchDep)==null?void 0:l.call(e,e.idx)},()=>{d()},{immediate:!0,deep:!0});const v=V(()=>r.tagMap.get(e.file.fullpath)??[]),b=V(()=>{const l=n.gridThumbnailResolution;return n.enableThumbnail?Me(e.file,[l,l].join("x")):Gt(e.file)}),E=V(()=>{var l;return(((l=n.conf)==null?void 0:l.all_custom_tags)??[]).reduce((s,c)=>[...s,{...c,selected:!!v.value.find(m=>m.id===c.id)}],[])}),w=V(()=>E.value.find(l=>l.type==="custom"&&l.name==="like")),T=()=>{ge(w.value),t("contextMenuClick",{key:`toggle-tag-${w.value.id}`},e.file,e.idx)};return(l,s)=>{const c=G,m=st,D=ot,O=nn,$=fn;return a(),R(c,{trigger:["contextmenu"],visible:Q(n).longPressOpenContextMenu?typeof l.idx=="number"&&l.showMenuIdx===l.idx:void 0,"onUpdate:visible":s[8]||(s[8]=g=>typeof l.idx=="number"&&t("update:showMenuIdx",g?l.idx:-1))},{overlay:k(()=>[l.enableRightClickMenu?(a(),R(Ke,{key:0,file:l.file,idx:l.idx,"selected-tag":v.value,onContextMenuClick:s[7]||(s[7]=(g,f,C)=>t("contextMenuClick",g,f,C)),"is-selected-mutil-files":l.isSelectedMutilFiles},null,8,["file","idx","selected-tag","is-selected-mutil-files"])):S("",!0)]),default:k(()=>{var g;return[(a(),h("li",{class:Y(["file file-item-trigger grid",{clickable:l.file.type==="dir",selected:l.selected}]),"data-idx":l.idx,key:l.file.name,draggable:"true",onDragstart:s[4]||(s[4]=f=>t("dragstart",f,l.idx)),onDragend:s[5]||(s[5]=f=>t("dragend",f,l.idx)),onClickCapture:s[6]||(s[6]=f=>t("fileItemClick",f,l.file,l.idx))},[u("div",null,[l.enableCloseIcon?(a(),h("div",{key:0,class:"close-icon",onClick:s[0]||(s[0]=f=>t("close-icon-click"))},[A(Q(Zt))])):S("",!0),l.enableRightClickMenu?(a(),h("div",Wr,[A(c,null,{overlay:k(()=>[A(Ke,{file:l.file,idx:l.idx,"selected-tag":v.value,onContextMenuClick:s[1]||(s[1]=(f,C,M)=>t("contextMenuClick",f,C,M)),"is-selected-mutil-files":l.isSelectedMutilFiles},null,8,["file","idx","selected-tag","is-selected-mutil-files"])]),default:k(()=>[u("div",Kr,[A(Q(Xt))])]),_:1}),l.file.type==="file"?(a(),R(c,{key:0},{overlay:k(()=>[E.value.length>1?(a(),R(D,{key:0,onClick:s[2]||(s[2]=f=>t("contextMenuClick",f,l.file,l.idx))},{default:k(()=>[(a(!0),h(H,null,J(E.value,f=>(a(),R(m,{key:`toggle-tag-${f.id}`},{default:k(()=>[I(y(f.name)+" ",1),f.selected?(a(),R(Q(at),{key:0})):(a(),R(Q(ut),{key:1}))]),_:2},1024))),128))]),_:1})):S("",!0)]),default:k(()=>{var f,C;return[u("div",{class:Y(["float-btn-wrap",{"like-selected":(f=w.value)==null?void 0:f.selected}]),onClick:T},[(C=w.value)!=null&&C.selected?(a(),R(Q(Rn),{key:0})):(a(),R(Q(Vn),{key:1}))],2)]}),_:1})):S("",!0)])):S("",!0),Q(en)(l.file.name)?(a(),h("div",{key:l.file.fullpath,class:Y(`idx-${l.idx} item-content`)},[l.enableChangeIndicator&&p.value&&o.value?(a(),R(Ur,{key:0,"gen-diff-to-next":p.value,"gen-diff-to-previous":o.value},null,8,["gen-diff-to-next","gen-diff-to-previous"])):S("",!0),A(O,{src:b.value,fallback:Q(Nn),preview:{src:l.fullScreenPreviewImageUrl,onVisibleChange:(f,C)=>t("previewVisibleChange",f,C)}},null,8,["src","fallback","preview"]),v.value&&l.cellWidth>he?(a(),h("div",Yr,[(a(!0),h(H,null,J(l.extraTags??v.value,f=>(a(),R($,{key:f.id,color:Q(r).getColor(f)},{default:k(()=>[I(y(f.name),1)]),_:2},1032,["color"]))),128))])):S("",!0)],2)):Q(tn)(l.file.name)?(a(),h("div",{key:3,class:Y(`idx-${l.idx} item-content video`),url:Q(de)(l.file),style:rt({"background-image":`url('${l.file.cover_url??Q(de)(l.file)}')`}),onClick:s[3]||(s[3]=f=>Q(sn)(l.file,C=>t("contextMenuClick",{key:`toggle-tag-${C}`},l.file,l.idx)))},[u("div",Gr,[u("img",{src:Q(Wn),style:{width:"40px",height:"40px"}},null,8,Zr)]),v.value&&l.cellWidth>he?(a(),h("div",Xr,[(a(!0),h(H,null,J(v.value,f=>(a(),R($,{key:f.id,color:Q(r).getColor(f)},{default:k(()=>[I(y(f.name),1)]),_:2},1032,["color"]))),128))])):S("",!0)],14,qr)):(a(),h("div",es,[l.file.type==="file"?(a(),R(Q(bn),{key:0,class:"icon center"})):(g=l.coverFiles)!=null&&g.length&&l.cellWidth>160?(a(),h("div",ts,[(a(!0),h(H,null,J(l.coverFiles,f=>(a(),h("img",{class:"dir-cover-item",src:f.media_type==="image"?Q(Me)(f):Q(de)(f),key:f.fullpath},null,8,ns))),128))])):(a(),R(Q(In),{key:2,class:"icon center"}))])),l.cellWidth>he?(a(),h("div",is,[u("div",{class:"name line-clamp-1",title:l.file.name},y(l.file.name),9,rs),u("div",ss,[u("div",os,y(l.file.type)+" "+y(l.file.size),1),u("div",null,y(l.file.date),1)])])):S("",!0)])],42,Jr))]}),_:1},8,["visible"])}}});const _s=lt(ls,[["__scopeId","data-v-1c38fa7e"]]);export{_s as F,gs as N,Ke as _,ps as a,Is as b,ks as c,pt as d,Ss as e,Kn as f,q as g,ys as h,As as i,ms as j,bs as k,On as r,vs as s,qn as t,le as u};

extensions/sd-webui-infinite-image-browsing/vue/dist/assets/FileItem-fb268ce8.css

@@ -0,0 +1 @@
+.vue-recycle-scroller{position:relative}.vue-recycle-scroller.direction-vertical:not(.page-mode){overflow-y:auto}.vue-recycle-scroller.direction-horizontal:not(.page-mode){overflow-x:auto}.vue-recycle-scroller.direction-horizontal{display:flex}.vue-recycle-scroller__slot{flex:auto 0 0}.vue-recycle-scroller__item-wrapper{flex:1;box-sizing:border-box;overflow:hidden;position:relative}.vue-recycle-scroller.ready .vue-recycle-scroller__item-view{position:absolute;top:0;left:0;will-change:transform}.vue-recycle-scroller.direction-vertical .vue-recycle-scroller__item-wrapper{width:100%}.vue-recycle-scroller.direction-horizontal .vue-recycle-scroller__item-wrapper{height:100%}.vue-recycle-scroller.ready.direction-vertical .vue-recycle-scroller__item-view{width:100%}.vue-recycle-scroller.ready.direction-horizontal .vue-recycle-scroller__item-view{height:100%}.resize-observer[data-v-b329ee4c]{position:absolute;top:0;left:0;z-index:-1;width:100%;height:100%;border:none;background-color:transparent;pointer-events:none;display:block;overflow:hidden;opacity:0}.resize-observer[data-v-b329ee4c] object{display:block;position:absolute;top:0;left:0;height:100%;width:100%;overflow:hidden;pointer-events:none;z-index:-1}.ant-tag{box-sizing:border-box;margin:0 8px 0 0;color:#000000d9;font-size:14px;font-variant:tabular-nums;line-height:1.5715;list-style:none;font-feature-settings:"tnum";display:inline-block;height:auto;padding:0 7px;font-size:12px;line-height:20px;white-space:nowrap;background:#fafafa;border:1px solid #d9d9d9;border-radius:2px;opacity:1;transition:all .3s}.ant-tag,.ant-tag a,.ant-tag a:hover{color:#000000d9}.ant-tag>a:first-child:last-child{display:inline-block;margin:0 -8px;padding:0 8px}.ant-tag-close-icon{margin-left:3px;color:#00000073;font-size:10px;cursor:pointer;transition:all .3s}.ant-tag-close-icon:hover{color:#000000d9}.ant-tag-has-color{border-color:transparent}.ant-tag-has-color,.ant-tag-has-color a,.ant-tag-has-color a:hover,.ant-tag-has-color .anticon-close,.ant-tag-has-color .anticon-close:hover{color:#fff}.ant-tag-checkable{background-color:transparent;border-color:transparent;cursor:pointer}.ant-tag-checkable:not(.ant-tag-checkable-checked):hover{color:#d03f0a}.ant-tag-checkable:active,.ant-tag-checkable-checked{color:#fff}.ant-tag-checkable-checked{background-color:#d03f0a}.ant-tag-checkable:active{background-color:#ab2800}.ant-tag-hidden{display:none}.ant-tag-pink{color:#c41d7f;background:#fff0f6;border-color:#ffadd2}.ant-tag-pink-inverse{color:#fff;background:#eb2f96;border-color:#eb2f96}.ant-tag-magenta{color:#c41d7f;background:#fff0f6;border-color:#ffadd2}.ant-tag-magenta-inverse{color:#fff;background:#eb2f96;border-color:#eb2f96}.ant-tag-red{color:#cf1322;background:#fff1f0;border-color:#ffa39e}.ant-tag-red-inverse{color:#fff;background:#f5222d;border-color:#f5222d}.ant-tag-volcano{color:#d4380d;background:#fff2e8;border-color:#ffbb96}.ant-tag-volcano-inverse{color:#fff;background:#fa541c;border-color:#fa541c}.ant-tag-orange{color:#d46b08;background:#fff7e6;border-color:#ffd591}.ant-tag-orange-inverse{color:#fff;background:#fa8c16;border-color:#fa8c16}.ant-tag-yellow{color:#d4b106;background:#feffe6;border-color:#fffb8f}.ant-tag-yellow-inverse{color:#fff;background:#fadb14;border-color:#fadb14}.ant-tag-gold{color:#d48806;background:#fffbe6;border-color:#ffe58f}.ant-tag-gold-inverse{color:#fff;background:#faad14;border-color:#faad14}.ant-tag-cyan{color:#08979c;background:#e6fffb;border-color:#87e8de}.ant-tag-cyan-inverse{color:#fff;background:#13c2c2;border-color:#13c2c2}.ant-tag-lime{color:#7cb305;background:#fcffe6;border-color:#eaff8f}.ant-tag-lime-inverse{color:#fff;background:#a0d911;border-color:#a0d911}.ant-tag-green{color:#389e0d;background:#f6ffed;border-color:#b7eb8f}.ant-tag-green-inverse{color:#fff;background:#52c41a;border-color:#52c41a}.ant-tag-blue{color:#096dd9;background:#e6f7ff;border-color:#91d5ff}.ant-tag-blue-inverse{color:#fff;background:#1890ff;border-color:#1890ff}.ant-tag-geekblue{color:#1d39c4;background:#f0f5ff;border-color:#adc6ff}.ant-tag-geekblue-inverse{color:#fff;background:#2f54eb;border-color:#2f54eb}.ant-tag-purple{color:#531dab;background:#f9f0ff;border-color:#d3adf7}.ant-tag-purple-inverse{color:#fff;background:#722ed1;border-color:#722ed1}.ant-tag-success{color:#52c41a;background:#f6ffed;border-color:#b7eb8f}.ant-tag-processing{color:#d03f0a;background:#fff1e6;border-color:#f7ae83}.ant-tag-error{color:#ff4d4f;background:#fff2f0;border-color:#ffccc7}.ant-tag-warning{color:#faad14;background:#fffbe6;border-color:#ffe58f}.ant-tag>.anticon+span,.ant-tag>span+.anticon{margin-left:7px}.ant-tag.ant-tag-rtl{margin-right:0;margin-left:8px;direction:rtl;text-align:right}.ant-tag-rtl .ant-tag-close-icon{margin-right:3px;margin-left:0}.ant-tag-rtl.ant-tag>.anticon+span,.ant-tag-rtl.ant-tag>span+.anticon{margin-right:7px;margin-left:0}.changeIndicators[data-v-78cd67a3]{position:absolute;display:flex;flex-direction:column;height:100%;align-items:center;justify-content:center;opacity:.6}.changeIndicatorsRight[data-v-78cd67a3]{position:absolute;right:0}.changeIndicator[data-v-78cd67a3]{margin-left:-4px;width:16px;height:16px;border-radius:2px;border:1px solid rgba(255,255,255,.2);background-color:gray;line-height:16px;margin-bottom:2px;text-align:center;font-size:6pt;font-weight:600;color:#000;z-index:9999;pointer-events:auto;box-shadow:0 0 4px #00000080}.changeIndicatorsRight .changeIndicator[data-v-78cd67a3]{margin-right:-4px;border-top-right-radius:8px;border-bottom-right-radius:8px;text-align:left;padding-left:2px}.changeIndicatorsLeft .changeIndicator[data-v-78cd67a3]{border-top-left-radius:8px;border-bottom-left-radius:8px;text-align:right;padding-right:2px}.changeIndicatorWrapper[data-v-78cd67a3]{top:0;position:absolute;user-select:none;width:100%;height:100%;z-index:999999;pointer-events:none}.hoverOverlay[data-v-78cd67a3]{display:none;background-color:#000c;color:#fff;border:1px solid gray;padding:10px 20px;border-radius:5px;z-index:100;opacity:1;font-size:8pt;line-height:1.2;overflow:hidden}.hoverOverlay ul[data-v-78cd67a3]{list-style:none;padding:0}.hoverOverlay ul li[data-v-78cd67a3]{display:inline-block;padding-left:4px;padding-right:4px;border:1px solid gray;border-radius:2px;margin:1px;font-weight:200}.changeIndicators[data-v-78cd67a3]:hover{opacity:1}.changeIndicators:hover+div.hoverOverlay[data-v-78cd67a3]{display:block;position:absolute;top:0;left:0;width:100%;height:100%}table tr td:first-child span[data-v-78cd67a3]{padding:1px 3px;display:inline-block;width:100%}table tr td[data-v-78cd67a3]:first-child{padding-right:10px;vertical-align:top}.otherChangeIndicator[data-v-78cd67a3]{background-color:#8b5b8e;color:#efefef}.stepsChangeIndicator[data-v-78cd67a3]{background-color:#577ab8;color:#efefef}.seedChangeIndicator[data-v-78cd67a3]{background-color:#649da3;color:#121}.negpromptChangeIndicator[data-v-78cd67a3]{background-color:#d8a390;color:#2f2f2f}.modelChangeIndicator[data-v-78cd67a3]{background-color:#d68679;color:#efefef}.promptChangeIndicator[data-v-78cd67a3]{background-color:#8fba99;color:#121}.cfgChangeIndicator[data-v-78cd67a3]{background-color:#d4c98f;color:#121}.sizeChangeIndicator[data-v-78cd67a3]{background-color:#678a6c;color:#efefef}.center[data-v-1c38fa7e]{display:flex;justify-content:center;align-items:center}.item-content[data-v-1c38fa7e]{position:relative}.item-content.video[data-v-1c38fa7e]{background-color:var(--zp-border);border-radius:8px;overflow:hidden;width:var(--02c5ba15);height:var(--02c5ba15);background-size:cover;background-position:center;cursor:pointer}.item-content .play-icon[data-v-1c38fa7e]{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);border-radius:100%;display:flex}.item-content .tags-container[data-v-1c38fa7e]{position:absolute;right:8px;bottom:8px;display:flex;width:calc(100% - 16px);flex-wrap:wrap-reverse;flex-direction:row-reverse}.item-content .tags-container>*[data-v-1c38fa7e]{margin:0 0 4px 4px;font-size:14px;line-height:1.6}.close-icon[data-v-1c38fa7e]{position:absolute;top:0;right:0;transform:translate(50%,-50%) scale(1.5);cursor:pointer;z-index:100;border-radius:100%;overflow:hidden;line-height:1;background-color:var(--zp-primary-background)}.file[data-v-1c38fa7e]{padding:8px 16px;margin:8px;display:flex;align-items:center;background:var(--zp-primary-background);border-radius:8px;box-shadow:0 0 4px var(--zp-secondary-variant-background);position:relative}.file:hover .more[data-v-1c38fa7e]{opacity:1}.file .more[data-v-1c38fa7e]{opacity:0;transition:all .3s ease;position:absolute;top:4px;right:4px;z-index:100;display:flex;align-items:center;justify-content:center;flex-direction:column;line-height:1em}.file .more .float-btn-wrap[data-v-1c38fa7e]{font-size:1.5em;cursor:pointer;font-size:500;padding:4px;border-radius:100vh;color:#fff;background:var(--zp-icon-bg);margin-bottom:4px}.file .more .float-btn-wrap.like-selected[data-v-1c38fa7e]{color:#df0505}.file.grid[data-v-1c38fa7e]{padding:0;display:inline-block;box-sizing:content-box;box-shadow:unset;background-color:var(--zp-secondary-background)}.file.grid[data-v-1c38fa7e] .icon{font-size:8em}.file.grid[data-v-1c38fa7e] .profile{padding:0 4px}.file.grid[data-v-1c38fa7e] .profile .name{font-weight:500;padding:0}.file.grid[data-v-1c38fa7e] .profile .basic-info{display:flex;justify-content:space-between;flex-direction:row;margin:0;font-size:.7em}.file.grid[data-v-1c38fa7e] .profile .basic-info *{white-space:nowrap;overflow:hidden}.file.grid[data-v-1c38fa7e] .ant-image,.file.grid[data-v-1c38fa7e] .preview-icon-wrap{border:1px solid var(--zp-secondary);background-color:var(--zp-secondary-variant-background);border-radius:8px;overflow:hidden}.file.grid[data-v-1c38fa7e] img:not(.dir-cover-item),.file.grid[data-v-1c38fa7e] .dir-cover-container,.file.grid[data-v-1c38fa7e] .preview-icon-wrap>[role=img]{height:var(--02c5ba15);width:var(--02c5ba15);object-fit:contain}.file.clickable[data-v-1c38fa7e]{cursor:pointer}.file.selected[data-v-1c38fa7e]{outline:#0084ff solid 2px}.file .name[data-v-1c38fa7e]{flex:1;padding:8px;word-break:break-all}.file .basic-info[data-v-1c38fa7e]{overflow:hidden;display:flex;flex-direction:column;align-items:flex-end}.file .dir-cover-container[data-v-1c38fa7e]{top:0;display:flex;flex-wrap:wrap;padding:4px}.file .dir-cover-container>img[data-v-1c38fa7e]{width:calc(50% - 8px);height:calc(50% - 8px);margin:4px;object-fit:cover;border-radius:8px;overflow:hidden}

extensions/sd-webui-infinite-image-browsing/vue/dist/assets/ImgSliPagePane-5f17c067.js

@@ -0,0 +1 @@
+import{d as a,S as t,T as s,c as n,cx as _,Z as o}from"./index-5b5fdd56.js";const c={class:"img-sli-container"},i=a({__name:"ImgSliPagePane",props:{paneIdx:{},tabIdx:{},left:{},right:{}},setup(l){return(e,r)=>(t(),s("div",c,[n(_,{left:e.left,right:e.right},null,8,["left","right"])]))}});const d=o(i,[["__scopeId","data-v-ae3fb9a8"]]);export{d as default};

extensions/sd-webui-infinite-image-browsing/vue/dist/assets/ImgSliPagePane-868b21f8.css

@@ -0,0 +1 @@
+.img-sli-container[data-v-ae3fb9a8]{position:relative;overflow-y:auto;height:calc(100vh - 40px)}