/** * @name ImageFolder * @description A BetterDiscord plugin that allows you to save and send images from a folder for easy access * @version 1.7.1 * @author TheLazySquid * @authorId 619261917352951815 * @website https://github.com/TheLazySquid/BetterDiscordPlugins * @source https://github.com/TheLazySquid/BetterDiscordPlugins/tree/main/plugins/ImageFolder/ImageFolder.plugin.js * @invite fKdAaFYbD5 */ /*@cc_on @if (@_jscript) // Offer to self-install for clueless users that try to run this directly. var shell = WScript.CreateObject("WScript.Shell"); var fs = new ActiveXObject("Scripting.FileSystemObject"); var pathPlugins = shell.ExpandEnvironmentStrings("%APPDATA%\\BetterDiscord\\plugins"); var pathSelf = WScript.ScriptFullName; // Put the user at ease by addressing them in the first person shell.Popup("It looks like you've mistakenly tried to run me directly. \n(Don't do that!)", 0, "I'm a plugin for BetterDiscord", 0x30); if (fs.GetParentFolderName(pathSelf) === fs.GetAbsolutePathName(pathPlugins)) { shell.Popup("I'm in the correct folder already.", 0, "I'm already installed", 0x40); } else if (!fs.FolderExists(pathPlugins)) { shell.Popup("I can't find the BetterDiscord plugins folder.\nAre you sure it's even installed?", 0, "Can't install myself", 0x10); } else if (shell.Popup("Should I copy myself to BetterDiscord's plugins folder for you?", 0, "Do you need some help?", 0x34) === 6) { fs.CopyFile(pathSelf, fs.BuildPath(pathPlugins, fs.GetFileName(pathSelf)), true); // Show the user where to put plugins in the future shell.Exec("explorer " + pathPlugins); shell.Popup("I'm installed!", 0, "Successfully installed", 0x40); } WScript.Quit(); @else@*/ module.exports = class { constructor() { let plugin = this; var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) { if (typeof require !== "undefined") return require.apply(this, arguments); throw Error('Dynamic require of "' + x + '" is not supported'); }); var __toBinary = /* @__PURE__ */ (() => { var table = new Uint8Array(128); for (var i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i; return (base64) => { var n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == "=") - (base64[n - 2] == "=")) * 3 / 4 | 0); for (var i2 = 0, j = 0; i2 < n; ) { var c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)]; var c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)]; bytes[j++] = c0 << 2 | c1 >> 4; bytes[j++] = c1 << 4 | c2 >> 2; bytes[j++] = c2 << 6 | c3; } return bytes; }; })(); // meta-ns:meta var pluginName = "ImageFolder"; // shared/bd.ts var Api = /* @__PURE__ */ new BdApi(pluginName); var started = false; var createCallbackHandler = (callbackName, changeStarted) => { let callbacks = []; plugin[callbackName] = () => { if (typeof changeStarted === "boolean") started = changeStarted; for (let i = 0; i < callbacks.length; i++) { callbacks[i].callback(); if (callbacks[i].once) { callbacks.splice(i, 1); i--; } } }; return (callback, once) => { if (changeStarted && started) { callback(); if (once) return; } callbacks.push({ callback, once }); }; }; var onStart = createCallbackHandler("start", true); var onStop = createCallbackHandler("stop", false); function setSettingsPanel(el) { if (typeof el === "function") plugin.getSettingsPanel = el; plugin.getSettingsPanel = () => el; } // shared/api/patching.ts function check(module, key) { if (!module || !key) { Api.Logger.warn("Missing module or key", module, key); return false; } return true; } function after(module, key, callback) { if (!check(module, key)) return; onStart(() => { Api.Patcher.after(module, key, (thisVal, args, returnVal) => { return callback({ thisVal, args, returnVal }); }); }); } function tempAfter(module, key, callback) { if (!check(module, key)) return; let unpatch = Api.Patcher.after(module, key, (thisVal, args, returnVal) => { unpatch?.(); return callback({ thisVal, args, returnVal }); }); } function afterClass(module, key, callback) { if (!check(module, key)) return; onStart(() => { const baseClass = module[key]; const newClass = class extends baseClass { constructor(...args) { super(...args); callback(this); } }; module[key] = newClass; onStop(() => module[key] = baseClass, true); }); } onStop(() => { Api.Patcher.unpatchAll(); }); // shared/util/modules.ts function getSyncModules(locators) { let returned = {}; const queries = locators.map(createQuery); const modules = BdApi.Webpack.getBulk(...queries); for (let i = 0; i < locators.length; i++) { const locator = locators[i]; const module = modules[i]; if (!module) { Api.Logger.warn(`Could not find module for ${locator.name}`); continue; } returned[locator.name] = finalizeModule(locator, module); } return returned; } function createQuery(locator) { return { filter: locator.filter, firstId: locator.id, defaultExport: locator.defaultExport, cacheId: locator.name, declarationFilter: locator.declarationFilter }; } function finalizeModule(locator, module) { if (locator.demangler) { return BdApi.Utils.mapObject(module, locator.demangler); } if (locator.getExport) { if (locator.getWithKey) { return findExportWithKey(module, locator.getExport); } else { return findExport(module, locator.getExport); } } if (locator.key) { return module[locator.key]; } return module; } function findExport(module, filter) { for (let value of Object.values(module)) { if (filter === true || filter(value)) return value; } } function findExportWithKey(module, filter) { for (let key in module) { if (filter !== true && !filter(module[key])) continue; return [module, key]; } } // modules-ns:$shared/modules var Filters = BdApi.Webpack.Filters; var { editorEvents, attachFiles, scroller, buttonsModule, expressionModule, expressionPicker, uploadAreaClass, chatbarInnerClass } = getSyncModules([ { name: "editorEvents", id: 392553, getExport: true, getWithKey: true, filter: Filters.bySource(",submit:", "selectPreviousCommandOption"), defaultExport: false }, { name: "attachFiles", id: 518960, getExport: (e) => e.toString().includes("filesMetadata"), getWithKey: true, filter: (m) => Object.values(m).some(Filters.byStrings("filesMetadata:", "requireConfirm:")) }, { name: "scroller", id: 584648, getExport: true, getWithKey: true, filter: Filters.bySource("isScrolledToBottom()", "shouldScrollToStart:"), defaultExport: false }, { name: "buttonsModule", id: 123583, filter: (m) => m.type?.toString?.().includes(".isSubmitButtonEnabled") }, { name: "expressionModule", id: 573853, filter: (m) => m.type?.toString?.().includes("onSelectGIF") && m.type?.toString?.().includes("hideGifFavorites") }, { name: "expressionPicker", id: 151271, demangler: { toggle: (f) => f.toString().includes("activeView==="), close: (f) => f.toString().includes("activeView:null"), store: (f) => f.getState }, filter: Filters.bySource("lastActiveView", "isSearchSuggestion") }, { name: "uploadAreaClass", key: "uploadArea", filter: Filters.byKeys("uploadArea", "chat") }, { name: "chatbarInnerClass", key: "inner", filter: Filters.byKeys("buttons", "textAreaSlate") } ]); // shared/api/toast.ts function success(message) { BdApi.UI.showToast(message, { type: "success" }); } function error(message) { BdApi.UI.showToast(message, { type: "error" }); } // shared/api/styles.ts var count = 0; function addStyle(css) { let styleId = count++; onStart(() => { Api.DOM.addStyle(`${pluginName}-${styleId}`, css); }); } onStop(() => { for (let i = 0; i < count; i++) { Api.DOM.removeStyle(`${pluginName}-${i}`); } }); // shared/ui/input.css addStyle(`.lazys-input { width: 100%; color: white; background-color: var(--background-highlight); border: 1px solid #bbb; border-radius: 5px; font-size: 20px; padding: 6px; }`); // shared/ui/input.tsx function Input({ onChange }) { const React = BdApi.React; const input = React.useRef(null); React.useEffect(() => { setTimeout(() => { input.current?.focus(); }, 100); }, []); return /* @__PURE__ */ BdApi.React.createElement( "input", { className: "lazys-input", placeholder: "...", onChange: (e) => onChange(e.target.value), ref: input } ); } function getInput(title, callback) { let text = ""; const onChange = (value) => text = value; BdApi.UI.showConfirmationModal(title, /* @__PURE__ */ BdApi.React.createElement(Input, { onChange }), { onConfirm: () => { if (text === "") return; callback(text); } }); } // shared/stores.ts var selectedChannelStore = /* @__PURE__ */ BdApi.Webpack.getStore("SelectedChannelStore"); var channelStore = /* @__PURE__ */ BdApi.Webpack.getStore("ChannelStore"); // shared/util/submitMessage.ts var submit = null; afterClass(...editorEvents, (instance) => { submit = instance.submit.bind(instance); }); function submitMessage() { if (!submit) { error("Could not send message, try switching channels"); return; } submit(); } // shared/util/upload.ts var scrollerInstance = null; after(...scroller, ({ returnVal }) => scrollerInstance = returnVal); async function uploadFile(file, autoSend) { const channelId = selectedChannelStore.getCurrentlySelectedChannelId(); if (!channelId) return; const channel = channelStore.getChannel(channelId); if (!channel) return; const attach = attachFiles[0][attachFiles[1]]; await attach([file], channel, 0, { requireConfirm: true, origin: "file_picker" }); if (!autoSend) return; submitMessage(); setTimeout(() => scrollerInstance?.scrollToBottom?.(), 0); } // shared/util/settings.ts function createSettings(panelSettings, defaults) { const settings2 = {}; for (let setting of panelSettings) { if (!setting.id) continue; settings2[setting.id] = Api.Data.load(setting.id) ?? defaults[setting.id]; } const onChangeCallbacks = {}; setSettingsPanel(() => { for (let setting of panelSettings) { setting.value = settings2[setting.id]; } return BdApi.UI.buildSettingsPanel({ settings: panelSettings, onChange: (_, id, value) => { settings2[id] = value; Api.Data.save(id, value); onChangeCallbacks[id]?.forEach((cb) => cb(value)); } }); }); settings2.onChange = (id, callback) => { onChangeCallbacks[id] ??= []; onChangeCallbacks[id].push(callback); }; return settings2; } // plugins/ImageFolder/src/settings.ts var settings = createSettings([ { type: "number", min: 1, max: 550, name: "Max preview size (megabytes)", note: "The entire item needs to be loaded into memory to be previewed, so very large previews can cause performance issues", id: "maxPreviewSize", step: 1 }, { type: "switch", name: "Show image folder button", note: "The image folder tab is still accessible inside of the expression picker menu", id: "showButton" }, { type: "switch", name: "Immediately send files", note: "Files will only be attached and can be sent manually later if disabled", id: "autoSend" }, { type: "text", name: "Image folder path", note: `Resolves relative to ${BdApi.Plugins.folder}`, id: "imageFolderPath" } ], { maxPreviewSize: 12, showButton: true, autoSend: true, imageFolderPath: "imageFolder" }); // plugins/ImageFolder/src/manager.ts var fs = __require("fs"); var path = __require("path"); var { shell } = __require("electron"); var types = { "jpg": ["image", "image/jpeg"], "jpeg": ["image", "image/jpeg"], "png": ["image", "image/png"], "webp": ["image", "image/webp"], "avif": ["image", "image/avif"], "gif": ["image", "image/gif"], "wav": ["audio", "audio/wav"], "mp3": ["audio", "audio/mpeg"], "ogg": ["audio", "audio/ogg"], "m4a": ["audio", "audio/flac"], "flac": ["audio", "audio/flac"], "mp4": ["video", "video/mp4"], "webm": ["video", "video/webm"], "mov": ["video", "video/quicktime"] }; var Manager = class { static base = path.resolve(BdApi.Plugins.folder, "imageFolder"); static dir = Api.Data.load("dir") ?? ""; static saveDir = Api.Data.load("saveDir") ?? this.base; static contents; static update; static { settings.onChange("imageFolderPath", (newPath) => { this.base = path.resolve(BdApi.Plugins.folder, newPath); Api.Logger.log(`Changing image folder path to ${this.base}`); this.saveDir = this.base; this.dir = ""; this.contents = void 0; Api.Data.save("dir", ""); Api.Data.save("saveDir", this.base); }); } static showFolder() { shell.openPath(path.join(this.base, this.dir)); } static read(dir, update) { this.update = update; if (this.dir === dir && this.contents) update(this.contents); let folders = []; let media = []; const fullPath = path.join(this.base, dir); if (!fs.existsSync(fullPath)) { fs.mkdir(fullPath, { recursive: true }, (err) => { if (err) return; Api.Data.save("dir", dir); this.dir = dir; this.contents = { folders, media }; update(this.contents); }); return; } fs.readdir(fullPath, { withFileTypes: true }, (err, files) => { if (err) { Api.Logger.error(err); error(`Failed to load ./${dir}`); return; } Api.Data.save("dir", dir); this.dir = dir; if (files.length === 0) { this.contents = { folders, media }; update(this.contents); return; } let typeSymbol = Object.getOwnPropertySymbols(files[0])[0]; for (let file of files) { const fileType = file[typeSymbol]; if (fileType === 2 || fileType === 3) { folders.push({ name: file.name }); continue; } const info = this.getInfo(file.name); if (!info) continue; const [type, mime] = info; const stat = fs.statSync(path.join(fullPath, file.name)); let lastUsed = Api.Data.load(`used-${path.join(this.dir, file.name)}`) ?? 0; media.push({ name: file.name, size: stat.size, type, mime, lastUsed }); } media.sort((a, b) => b.lastUsed - a.lastUsed); this.contents = { folders, media }; update(this.contents); }); } static getInfo(name) { const ext = name.split(".").pop(); if (!ext) return; return types[ext]; } static deleteMedia(media) { const fullPath = path.join(this.base, this.dir, media.name); fs.unlink(fullPath, (err) => { if (err) { Api.Logger.error(err); error(`Error deleting ${media.name}`); return; } }); if (!this.contents) return; Api.Data.delete(`used-${path.join(this.dir, media.name)}`); this.contents.media = this.contents.media.filter((m) => m !== media); this.update?.({ ...this.contents }); } static async renameMedia(media) { const mediaPath = path.join(this.base, this.dir, media.name); let dialog = await BdApi.UI.openDialog({ mode: "save", defaultPath: mediaPath, filters: [ { name: "Media", extensions: Object.keys(types) } ], title: "Rename media" }); if (dialog.canceled) return; try { fs.renameSync(mediaPath, dialog.filePath); let prevPath = path.join(this.dir, media.name); Api.Data.delete(`used-${prevPath}`); let relativePath = dialog.filePath.replace(this.base, "").slice(1); Api.Data.save(`used-${relativePath}`, media.lastUsed); success(`Successfully renamed to ${path.basename(dialog.filePath)}`); } catch (e) { Api.Logger.error(e); error(`Failed to rename ${media.name}`); } } static readWhole(media) { const fullPath = path.join(this.base, this.dir, media.name); return new Promise((res) => { fs.readFile(fullPath, "binary", (err, data) => { if (err) { Api.Logger.error(err); return res(null); } const arr = Uint8Array.from(data, (c) => c.charCodeAt(0)); const blob = new Blob([arr], { type: media.mime }); res(blob); }); }); } static async send(media) { const blob = await this.readWhole(media); if (!blob) return error(`Failed to read ${media.name}`); media.lastUsed = Date.now(); Api.Data.save(`used-${path.join(this.dir, media.name)}`, media.lastUsed); this.contents?.media.sort((a, b) => b.lastUsed - a.lastUsed); const file = new File([blob], media.name, { type: media.mime }); await uploadFile(file, settings.autoSend); } static createFolder() { getInput("Enter folder name", (name) => { if (!this.contents) return; try { if (this.contents.folders.some((f) => f.name === name)) { error(`A folder named ${name} already exists`); return; } fs.mkdirSync(path.join(this.base, this.dir, name)); this.contents.folders.push({ name }); this.update?.({ ...this.contents }); } catch (e) { Api.Logger.error(e); error("Failed to create folder"); } }); } static renameFolder(folder) { getInput("Enter new folder name", (name) => { if (!this.contents) return; try { fs.renameSync(path.join(this.base, this.dir, folder.name), path.join(this.base, this.dir, name)); if (!this.contents) return; folder.name = name; this.update?.({ ...this.contents }); } catch (e) { Api.Logger.error(e); error(`Failed to rename folder ${folder.name} to ${name}`); return; } }); } static deleteFolder(folder) { const fullPath = path.join(this.base, this.dir, folder.name); fs.rmdir(fullPath, { recursive: true }, (err) => { if (err) { Api.Logger.error(err); error(`Error deleting ${folder.name}`); return; } if (!this.contents) return; this.contents.folders = this.contents.folders.filter((f) => f !== folder); this.update?.({ ...this.contents }); }); } static async uploadMedia() { let input = document.createElement("input"); input.type = "file"; input.multiple = true; input.accept = Array.from(Object.keys(types)).map((e) => "." + e).join(","); input.click(); input.addEventListener("change", async () => { if (!input.files) return; this.addFileList(input.files); }); } static async addFileList(files, subdir) { await Promise.allSettled(Array.from(files).map(async (file) => { const info = this.getInfo(file.name); if (!info) return; const [type, mime] = info; let name = await this.copyFile(file, subdir); if (!name) return; Api.Data.save(`used-${path.join(this.dir, subdir ?? "", name)}`, Date.now()); if (subdir) return; this.contents?.media.unshift({ name, type, mime, size: file.size, lastUsed: Date.now() }); })); if (!this.contents) return; this.update?.({ ...this.contents }); } static async copyFile(file, subdir) { let parts = file.name.split("."); let base = parts.slice(0, -1).join("."); let ext = parts.pop(); const files = await new Promise((res) => { fs.readdir(path.join(this.base, this.dir, subdir ?? ""), {}, (err, contents) => { if (err) { Api.Logger.error(err); res(null); return; } res(contents); }); }); if (!files) { error("Failed to copy image since its containing directory could not be read"); return; } let name = file.name; let index = 2; while (files.includes(name)) name = `${base} (${index++}).${ext}`; if (name !== file.name) { file = new File([file], name, { type: file.type }); } const filePath = path.join(this.base, this.dir, subdir ?? "", file.name); const reader = file.stream().getReader(); await this.readToFile(filePath, reader); BdApi.UI.showToast(`Copied ${file.name}`, { type: "success" }); return file.name; } static async saveImage(url) { const name = url.split("/").pop()?.split("?").shift() ?? ""; const mediaPath = path.join(this.saveDir, name); let dialog = await BdApi.UI.openDialog({ mode: "save", defaultPath: mediaPath, filters: [ { name: "Media", extensions: Object.keys(types) } ], title: "Save media" }); if (dialog.canceled) return; let res = await BdApi.Net.fetch(url); if (!res.body) return; let reader = res.body.getReader(); await this.readToFile(dialog.filePath, reader); const dirname = path.dirname(dialog.filePath); const basename = path.basename(dialog.filePath); this.saveDir = dirname; Api.Data.save("saveDir", dirname); if (dialog.filePath.includes(this.base)) { let relativePath = dialog.filePath.replace(this.base, "").slice(1); Api.Data.save(`used-${relativePath}`, Date.now()); } success(`Downloaded ${basename}`); } static async readToFile(path2, reader) { const writeStream = fs.createWriteStream(path2); await new Promise((res) => writeStream.once("ready", res)); while (true) { const { done, value } = await reader.read(); if (done) break; writeStream.write(value); } writeStream.close(); } }; // shared/util/canvas.ts function getLines(ctx, text, maxWidth) { var words = text.split(" "); var lines = []; var currentLine = words[0]; for (var i = 1; i < words.length; i++) { var word = words[i]; var width = ctx.measureText(currentLine + " " + word).width; if (width < maxWidth) { currentLine += " " + word; } else { lines.push(currentLine); currentLine = word; } } lines.push(currentLine); return lines; } // plugins/ImageFolder/src/ui/captioner.tsx function Captioner({ media, onCanvas }) { const React = BdApi.React; const img = React.useRef(null); const [text, setText] = React.useState(""); const [size, setSize] = React.useState(30); const input = React.useRef(null); const canvas = React.useRef(null); const ctx = React.useRef(null); const render = () => { if (!canvas.current || !ctx.current || !img.current) return; let lines = getLines(ctx.current, text || "Enter caption...", img.current.width); let captionHeight = lines.length * size + 15; canvas.current.height = img.current.height + captionHeight; ctx.current.fillStyle = "white"; ctx.current.fillRect(0, 0, img.current.width, captionHeight); ctx.current.drawImage(img.current, 0, captionHeight); ctx.current.textAlign = "center"; ctx.current.textBaseline = "top"; ctx.current.font = `${size}px futuraBoldCondensed`; ctx.current.fillStyle = "black"; for (let i = 0; i < lines.length; i++) { ctx.current.fillText(lines[i], img.current.width / 2, size * i + 10); } }; React.useEffect(render, [text, size]); React.useEffect(() => { setTimeout(() => input.current?.focus(), 100); if (!canvas.current) return; onCanvas(canvas.current); ctx.current = canvas.current.getContext("2d"); let url; Manager.readWhole(media).then((blob) => { if (!blob) return; url = URL.createObjectURL(blob); let image = new Image(); image.src = url; image.onload = () => { if (!canvas.current) return; canvas.current.width = image.width; img.current = image; setSize(image.width / 10); render(); }; }); return () => { if (url) URL.revokeObjectURL(url); }; }, []); return /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-captioner" }, /* @__PURE__ */ BdApi.React.createElement( "input", { onChange: (e) => setText(e.target.value), ref: input, className: "if-caption", placeholder: "Enter caption..." } ), /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-fontsize" }, /* @__PURE__ */ BdApi.React.createElement("div", null, "Font size"), /* @__PURE__ */ BdApi.React.createElement( "input", { type: "range", min: 5, max: 200, value: size, onChange: (e) => setSize(parseFloat(e.target.value)) } )), /* @__PURE__ */ BdApi.React.createElement("canvas", { ref: canvas })); } // plugins/ImageFolder/src/ui/mediaDisplay.tsx function MediaDisplay({ media }) { const React = BdApi.React; const [url, setUrl] = React.useState(null); const wrap = React.useRef(null); const send = () => { Manager.send(media); expressionPicker.close(); }; React.useEffect(() => { if (!wrap.current || media.size > settings.maxPreviewSize * 1e6) return; let unloadTimeout; let url2; const observer = new IntersectionObserver((entries) => { for (let entry of entries) { if (entry.intersectionRatio == 0) { if (!url2) continue; unloadTimeout = setTimeout(() => { if (!url2) return; URL.revokeObjectURL(url2); url2 = void 0; setUrl(null); }, 1e4); } else { if (unloadTimeout) clearTimeout(unloadTimeout); if (url2) continue; Manager.readWhole(media).then((blob) => { if (!blob) return; url2 = URL.createObjectURL(blob); setUrl(url2); }); } } }); observer.observe(wrap.current); return () => { if (url2) URL.revokeObjectURL(url2); observer.disconnect(); }; }, []); const deleteMedia = () => { BdApi.UI.showConfirmationModal("Deletion confirmation", `Are you sure you want to delete ${media.name}?`, { danger: true, confirmText: "Confirm", onConfirm() { Manager.deleteMedia(media); } }); }; const showCaptioner = () => { let canvas; BdApi.UI.showConfirmationModal( "Add Caption", /* @__PURE__ */ BdApi.React.createElement(Captioner, { media, onCanvas: (c) => canvas = c }), { confirmText: "Send", onConfirm() { const err = () => error("An error occured getting the captioned image"); if (!canvas) return err(); canvas.toBlob((blob) => { if (!blob) return err(); const name = media.name.split(".").slice(0, -1).join(".") + "-captioned.png"; let file = new File([blob], name); uploadFile(file, settings.autoSend); expressionPicker.close(); }); } } ); }; const openContextMenu = (e) => { const setup = [ { id: "rename", type: "item", label: "Rename", onClick: () => Manager.renameMedia(media) }, { id: "delete", type: "item", label: "Delete", onClick: deleteMedia } ]; if (media.type === "image") { setup.push({ id: "caption", type: "item", label: "Send with Caption", onClick: showCaptioner }); } const menu = BdApi.ContextMenu.buildMenu(setup); BdApi.ContextMenu.open(e.nativeEvent, menu); }; return /* @__PURE__ */ BdApi.React.createElement("button", { ref: wrap, onClick: send, onContextMenu: openContextMenu }, media.size > settings.maxPreviewSize * 1e6 ? /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-no-preview" }, media.name, " is too large to be previewed") : url ? media.type === "image" ? /* @__PURE__ */ BdApi.React.createElement("img", { src: url }) : media.type === "audio" ? /* @__PURE__ */ BdApi.React.createElement("div", null, /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-audio-label" }, media.name), /* @__PURE__ */ BdApi.React.createElement("audio", { src: url, controls: true })) : /* @__PURE__ */ BdApi.React.createElement("video", { src: url, loop: true, autoPlay: true, muted: true }) : "loading..."); } // shared/ui/icons.tsx function LucideIcon({ icon, size = 24, color, className }) { const stroke = color ?? "currentColor"; return /* @__PURE__ */ BdApi.React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke, "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", className }, icon.map(([tag, attrs]) => BdApi.React.createElement(tag, attrs))); } // node_modules/lucide/dist/esm/icons/file-plus.js var FilePlus = [ [ "path", { d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z" } ], ["path", { d: "M14 2v5a1 1 0 0 0 1 1h5" }], ["path", { d: "M9 15h6" }], ["path", { d: "M12 18v-6" }] ]; // node_modules/lucide/dist/esm/icons/folder-open.js var FolderOpen = [ [ "path", { d: "m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2" } ] ]; // node_modules/lucide/dist/esm/icons/folder-output.js var FolderOutput = [ [ "path", { d: "M2 7.5V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-1.5" } ], ["path", { d: "M2 13h10" }], ["path", { d: "m5 10-3 3 3 3" }] ]; // node_modules/lucide/dist/esm/icons/folder-plus.js var FolderPlus = [ ["path", { d: "M12 10v6" }], ["path", { d: "M9 13h6" }], [ "path", { d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z" } ] ]; // node_modules/lucide/dist/esm/icons/folder-tree.js var FolderTree = [ [ "path", { d: "M20 10a1 1 0 0 0 1-1V6a1 1 0 0 0-1-1h-2.5a1 1 0 0 1-.8-.4l-.9-1.2A1 1 0 0 0 15 3h-2a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z" } ], [ "path", { d: "M20 21a1 1 0 0 0 1-1v-3a1 1 0 0 0-1-1h-2.9a1 1 0 0 1-.88-.55l-.42-.85a1 1 0 0 0-.92-.6H13a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z" } ], ["path", { d: "M3 5a2 2 0 0 0 2 2h3" }], ["path", { d: "M3 3v13a2 2 0 0 0 2 2h3" }] ]; // node_modules/lucide/dist/esm/icons/image-plus.js var ImagePlus = [ ["path", { d: "M16 5h6" }], ["path", { d: "M19 2v6" }], ["path", { d: "M21 11.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7.5" }], ["path", { d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" }], ["circle", { cx: "9", cy: "9", r: "2" }] ]; // node_modules/lucide/dist/esm/icons/search.js var Search = [ ["path", { d: "m21 21-4.34-4.34" }], ["circle", { cx: "11", cy: "11", r: "8" }] ]; // plugins/ImageFolder/src/ui/folderDisplay.tsx function FolderDisplay({ folder, onClick }) { const React = BdApi.React; const onContextMenu = (e) => { BdApi.ContextMenu.open(e.nativeEvent, BdApi.ContextMenu.buildMenu([ { id: "rename", type: "item", label: "Rename", onClick: () => Manager.renameFolder(folder) }, { id: "delete", type: "item", label: "Delete", onClick: () => { BdApi.UI.showConfirmationModal("Deletion confirmation", `Are you sure you want to delete ${folder.name}?`, { danger: true, confirmText: "Confirm", onConfirm() { Manager.deleteFolder(folder); } }); } } ])); }; const [canDrop, setCanDrop] = React.useState(false); const dragEnterCount = React.useRef(0); const onDragOver = (e) => { e.preventDefault(); }; const onDragEnter = () => { dragEnterCount.current++; console.log("Can drop"); setCanDrop(true); }; const onDragLeave = () => { dragEnterCount.current--; setCanDrop(dragEnterCount.current > 0); }; const onDrop = (e) => { e.preventDefault(); dragEnterCount.current = 0; setCanDrop(false); if (!e.dataTransfer.files) return; Manager.addFileList(e.dataTransfer.files, folder.name); }; return /* @__PURE__ */ BdApi.React.createElement( "button", { className: `if-folder ${canDrop ? "highlighted" : ""}`, onDrop, onDragOver, onDragEnter, onDragLeave, onContextMenu, onClick }, /* @__PURE__ */ BdApi.React.createElement(LucideIcon, { icon: FolderOpen }), folder.name ); } // plugins/ImageFolder/src/ui/view.tsx function View() { const React = BdApi.React; const [dir, setDir] = React.useState(Manager.dir); const [contents, setContents] = React.useState({ folders: [], media: [] }); const clear = () => setContents({ folders: [], media: [] }); const navigate = (subdir) => { clear(); if (dir === "") setDir(subdir); else setDir(dir + "/" + subdir); }; const moveBack = () => { clear(); setDir(dir.split("/").slice(0, -1).join("/")); }; const setDepth = (depth) => { clear(); setDir(dir.split("/").slice(0, depth + 1).join("/")); }; React.useEffect(() => { Manager.read(dir, setContents); }, [dir]); const [canDrop, setCanDrop] = React.useState(false); const dragEnterCount = React.useRef(0); const onDragOver = (e) => { e.preventDefault(); }; const onDragEnter = () => { dragEnterCount.current++; setCanDrop(true); }; const onDragLeave = () => { dragEnterCount.current--; setCanDrop(dragEnterCount.current > 0); }; const onDrop = (e) => { e.preventDefault(); dragEnterCount.current = 0; setCanDrop(false); if (!e.dataTransfer.files) return; Manager.addFileList(e.dataTransfer.files); }; const [searching, setSearching] = React.useState(false); const [searchText, setSearchText] = React.useState(""); const [showContents, setShowContents] = React.useState({ folders: [], media: [] }); React.useEffect(() => { if (searching) { const searched = searchText.trim().toLowerCase(); setShowContents({ folders: contents.folders.filter((f) => f.name.toLowerCase().includes(searched)), media: contents.media.filter((m) => m.name.toLowerCase().includes(searched)) }); } else { setShowContents({ folders: contents.folders, media: contents.media }); } }, [searching, searchText, contents]); React.useEffect(() => { setSearching(false); setSearchText(""); }, [dir]); const searchKeyDown = (e) => { e.stopPropagation(); if (e.code === "Escape") { setSearching(false); setSearchText(""); } }; React.useEffect(() => { const onClick = () => setSearching(false); const onKeyDown = (e) => { if (e.ctrlKey && e.key === "f") { e.preventDefault(); e.stopPropagation(); setSearching(true); } }; window.addEventListener("click", onClick); window.addEventListener("keydown", onKeyDown, true); return () => { window.removeEventListener("click", onClick); window.removeEventListener("keydown", onKeyDown, true); }; }, []); const startSearch = (e) => { e.stopPropagation(); setSearching(true); }; const searchInput = React.useCallback((node) => { if (node) node.focus(); }, []); return /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-view" }, /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-controls" }, /* @__PURE__ */ BdApi.React.createElement("button", { title: "Upload media", onClick: () => Manager.uploadMedia() }, /* @__PURE__ */ BdApi.React.createElement(LucideIcon, { icon: FilePlus })), /* @__PURE__ */ BdApi.React.createElement("button", { title: "Create folder", onClick: () => Manager.createFolder() }, /* @__PURE__ */ BdApi.React.createElement(LucideIcon, { icon: FolderPlus })), /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-search" }, /* @__PURE__ */ BdApi.React.createElement("button", { className: "if-search-icon", onClick: startSearch }, /* @__PURE__ */ BdApi.React.createElement(LucideIcon, { icon: Search })), searching ? /* @__PURE__ */ BdApi.React.createElement( "input", { type: "text", value: searchText, ref: searchInput, onChange: (e) => setSearchText(e.target.value), onKeyDown: searchKeyDown, spellCheck: false, placeholder: "Search by filename" } ) : null), /* @__PURE__ */ BdApi.React.createElement("button", { title: "Reveal in file manager", onClick: () => Manager.showFolder() }, /* @__PURE__ */ BdApi.React.createElement(LucideIcon, { icon: FolderTree }))), dir !== "" ? /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-path" }, /* @__PURE__ */ BdApi.React.createElement("button", { className: "if-back", onClick: () => moveBack() }, /* @__PURE__ */ BdApi.React.createElement(LucideIcon, { icon: FolderOutput })), /* @__PURE__ */ BdApi.React.createElement("button", { onClick: () => { clear(); setDir(""); } }, "/"), dir.split("/").map((subdir, i, arr) => /* @__PURE__ */ BdApi.React.createElement(React.Fragment, null, /* @__PURE__ */ BdApi.React.createElement("button", { onClick: () => setDepth(i) }, subdir), i !== arr.length - 1 ? /* @__PURE__ */ BdApi.React.createElement("button", { onClick: () => setDepth(i) }, "/") : null))) : null, /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-content" }, /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-folder-list" }, showContents.folders.map((folder) => /* @__PURE__ */ BdApi.React.createElement( FolderDisplay, { folder, onClick: () => navigate(folder.name), key: dir + "/" + folder.name } ))), /* @__PURE__ */ BdApi.React.createElement( "div", { className: `if-media-list ${canDrop ? "highlighted" : ""}`, onDrop, onDragOver, onDragEnter, onDragLeave }, showContents.media.length === 0 && searchText === "" ? /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-no-media" }, "There isn't any media in this folder! Use the button at the top left or drag and drop to upload some.") : null, showContents.media.length === 0 && showContents.folders.length === 0 && searchText !== "" ? /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-no-media" }, 'No results found for "', searchText, '"') : null, showContents.media.map((media) => /* @__PURE__ */ BdApi.React.createElement("div", { className: "if-media", key: dir + "/" + media.name }, /* @__PURE__ */ BdApi.React.createElement(MediaDisplay, { media }))) ))); } // shared/api/fonts.ts function addFont(data, family) { onStart(() => { for (let font2 of document.fonts) { if (font2.family === family) return; } let font = new FontFace(family, data); document.fonts.add(font); onStop(() => { document.fonts.delete(font); }, true); }); } // assets/Futura Condensed Extra Bold.otf var Futura_Condensed_Extra_Bold_default = __toBinary("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"); // plugins/ImageFolder/src/styles.css addStyle(`.if-button { aspect-ratio: 1 / 1; padding: 0; cursor: pointer; width: 28px; height: 28px; border-radius: 8px; transition-duration: 0.2s; display: flex; align-items: center; justify-content: center; } .if-button:hover { background-color: var(--interactive-background-selected); } .if-button svg { width: 23px; height: 23px; color: var(--interactive-text-default); } .if-button:hover svg { color: var(--interactive-text-hover); } .if-view { width: 100%; height: 100%; display: flex; flex-direction: column; min-height: 0; } .if-view svg { width: 28px; height: 28px; color: #15A4C1; } .if-path, .if-back, .if-controls { display: flex; align-items: center; } .if-controls { padding: 0 6px; } .if-path { padding-left: 8px; } .if-path button, .if-controls button { background-color: transparent; color: white; padding: 0; margin: 0; padding-right: 3px; } .if-content { overflow-x: hidden; overflow-y: auto; scrollbar-width: thin; scrollbar-color: var(--background-accent) transparent; } .if-media-list { display: grid; grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); overflow-y: auto; gap: 3px; flex-grow: 1; align-content: flex-start; padding: 3px; } .if-media-list.highlighted { background-color: var(--background-accent); border: 1px solid #ddd; border-radius: 5px; } .if-folder-list { display: flex; flex-direction: column; } .if-folder { display: flex; background-color: var(--background-accent); color: white; align-items: center; padding: 5px; border-radius: 5px; gap: 3px; margin: 3px; font-size: 16px; } .if-folder.highlighted { filter: brightness(1.3); } .if-media { height: 200px; border: 1px dashed #aaa; border-radius: 5px; } .if-media > button { width: 100%; height: 100%; background-color: transparent; color: white; } .if-audio-label { width: 100%; text-align: center; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; } .if-media audio { width: 100%; height: 40px; } .if-media img, .if-media video { width: 100%; height: 100%; object-fit: contain; } .if-no-preview { width: 100%; height: 100%; word-break: break-word; text-align: center; align-content: center; } .if-captioner { display: flex; flex-direction: column; } .if-captioner canvas { width: 100%; } .if-caption { background-color: var(--background-accent); color: white; border: 1px solid black; border-radius: 5px; padding: 4px; } .if-fontsize { display: flex; align-items: center; gap: 5px; color: white; margin: 10px 0; } .if-fontsize input { flex-grow: 1; } .if-no-media { grid-column: 1 / -1; color: white; text-align: center; font-size: 16px; border: 1px dashed #aaa; border-radius: 5px; align-content: center; height: 130px; } .if-search { flex-grow: 1; display: flex; } .if-search input { flex-grow: 1; background-color: transparent; border: none; border-bottom: 1px solid #aaa; color: white; font-size: 16px; }`); // shared/api/contextmenu.ts function patchContextMenu(type, callback) { onStart(() => BdApi.ContextMenu.patch(type, callback)); onStop(() => BdApi.ContextMenu.unpatch(type, callback)); } // shared/util/react.ts function findReactChild(element, filter) { if (!element) return null; return BdApi.Utils.findInTree(element, filter, { walkable: ["props", "children"] }); } function forceUpdate(selector) { const target = document.querySelector(selector)?.parentElement; if (!target) return; const instance = BdApi.ReactUtils.getOwnerInstance(target); if (!instance) return; const unpatch = Api.Patcher.instead(instance, "render", () => unpatch?.()); instance.forceUpdate(() => instance.forceUpdate()); } // plugins/ImageFolder/src/index.ts addFont(Futura_Condensed_Extra_Bold_default, "futuraBoldCondensed"); after(buttonsModule, "type", ({ args, returnVal }) => { if (!returnVal || !settings.showButton || args[0].disabled) return returnVal; let gifIndex = returnVal.props.children.findIndex((child) => child.key == "gif"); if (gifIndex === -1) return; let type = returnVal.props.children[gifIndex].props.type; let div = BdApi.React.createElement("div", { className: "if-button", onMouseDown: () => { const channel = selectedChannelStore.getChannelId(); setTimeout(() => expressionPicker.toggle("if-image", type, channel)); }, key: "if-image" }, BdApi.React.createElement(LucideIcon, { icon: ImagePlus })); returnVal.props.children.splice(gifIndex, 0, div); return returnVal; }); onStart(() => { forceUpdate("." + chatbarInnerClass); }); after(expressionModule, "type", ({ returnVal }) => { if (!returnVal) return returnVal; tempAfter(returnVal.props.children.props, "children", ({ returnVal: returnVal2 }) => { if (!returnVal2) return returnVal2; let sections = findReactChild(returnVal2, (el) => el?.[0]?.type === "nav"); let categories = findReactChild(sections, (el) => el?.[0]?.props?.["aria-selected"] !== void 0); if (!categories) return; let activeView = expressionPicker.store.getState().activeView; let newCategory = BdApi.React.createElement(categories[0].type, { id: "image-folder-tab", "aria-controls": "image-folder-tab-panel", "aria-selected": activeView === "if-image", isActive: activeView === "if-image", viewType: "if-image", children: "Media" }); categories.splice(0, 0, newCategory); if (activeView === "if-image") { const el = BdApi.React.createElement(View, {}); sections.push(el); } }); }); var hideCss = `.${uploadAreaClass} { display: none; pointer-events: none; }`; onStart(() => { let unsub = expressionPicker.store.subscribe((state) => { if (state.activeView) { BdApi.DOM.addStyle("if-hide-upload", hideCss); } else { BdApi.DOM.removeStyle("if-hide-upload"); } }); onStop(unsub, true); }); onStop(() => { BdApi.DOM.removeStyle("if-hide-upload"); }); patchContextMenu("message", (element, props) => { if (!props?.mediaItem) return; if (Object.values(types).every((t) => t[1] !== props.mediaItem.contentType)) return; element.props.children.props.children.push( BdApi.ContextMenu.buildItem({ type: "separator" }), BdApi.ContextMenu.buildItem({ id: "addToImageFolder", type: "item", label: "Add to ImageFolder", onClick: () => Manager.saveImage(props.mediaItem.url) }) ); }); var onPaste = (e) => { if (expressionPicker.store.getState().activeView !== "if-image") return; e.stopPropagation(); let files = e.clipboardData?.files; if (files) Manager.addFileList(files); }; onStart(() => window.addEventListener("paste", onPaste, true)); onStop(() => window.removeEventListener("paste", onPaste, true)); } } /*@end@*/