frida-float-menu 1.0.0

package/lib/component/views/log-view.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogView = void 0;
+const api_1 = require("../../api");
+const logger_1 = require("../../logger");
+const style_1 = require("../style/style");
+class LogView {
+    constructor(context, height, theme, logMaxLines = 100) {
+        this.isLogDrawerOpen = false;
+        this._logMaxLinesCache = 0;
+        this._logRing = null;
+        this._logHead = 0;
+        this._logSize = 0;
+        this._logPending = [];
+        this._logFlushScheduled = false;
+        this.context = context;
+        this.height = height;
+        this.logMaxLines = logMaxLines;
+        this.theme = theme;
+    }
+    bindLoggerToLogViewOnce() {
+        if (this._loggerUnsub)
+            return;
+        const self = this;
+        this._loggerUnsub = logger_1.Logger.instance.onLog((items) => {
+            for (let i = 0; i < items.length; i++) {
+                const it = items[i];
+                self.addLogToView(it.level, it.message, it.ts);
+            }
+        }, true);
+    }
+    addLogToView(level, message, ts) {
+        if (!this.logView)
+            return;
+        const maxLines = this.logMaxLines | 0;
+        if (maxLines <= 0)
+            return;
+        if (!this._logRing || this._logMaxLinesCache !== maxLines) {
+            this._logMaxLinesCache = maxLines;
+            this._logRing = new Array(maxLines);
+            this._logHead = 0;
+            this._logSize = 0;
+            this._logPending.length = 0;
+            this._logFlushScheduled = false;
+            this.logView.setText(api_1.API.JString.$new(""));
+        }
+        this._logPending.push(`[${level.toUpperCase()} ${new Date(ts).toTimeString().substring(0, 8)}] ${message}`);
+        if (this._logFlushScheduled)
+            return;
+        this._logFlushScheduled = true;
+        Java.scheduleOnMainThread(() => {
+            this._logFlushScheduled = false;
+            if (!this.logView || !this._logRing)
+                return;
+            while (this._logPending.length > 0) {
+                const line = this._logPending.shift();
+                this._logRing[this._logHead] = line;
+                this._logHead = (this._logHead + 1) % this._logMaxLinesCache;
+                if (this._logSize < this._logMaxLinesCache)
+                    this._logSize++;
+            }
+            let out = "";
+            const start = (this._logHead - this._logSize + this._logMaxLinesCache) %
+                this._logMaxLinesCache;
+            for (let i = 0; i < this._logSize; i++) {
+                const idx = (start + i) % this._logMaxLinesCache;
+                const s = this._logRing[idx];
+                if (s == null)
+                    continue;
+                out += s;
+                if (i !== this._logSize - 1)
+                    out += "\n";
+            }
+            this.logView.setText(api_1.API.JString.$new(out));
+        });
+    }
+    createViewOnce(parentView) {
+        if (!parentView) {
+            console.error("LogView: parentView is null");
+            return;
+        }
+        this.parentView = parentView;
+        if (this.logDrawerPanel)
+            return;
+        const LinearLayout = api_1.API.LinearLayout;
+        const FrameLayoutParams = api_1.API.FrameLayoutParams;
+        const ViewGroupLayoutParams = api_1.API.ViewGroupLayoutParams;
+        const Gravity = api_1.API.Gravity;
+        const GradientDrawable = api_1.API.GradientDrawable;
+        const ctx = this.context;
+        try {
+            this.parentView.setClipChildren(false);
+        }
+        catch { }
+        try {
+            this.parentView.setClipToPadding(false);
+        }
+        catch { }
+        const panel = LinearLayout.$new(this.context);
+        panel.setOrientation(LinearLayout.VERTICAL.value);
+        const panelLp = FrameLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, this.height);
+        panelLp.gravity.value = Gravity.BOTTOM.value;
+        panel.setLayoutParams(panelLp);
+        panel.setAlpha(0.9);
+        const bg = GradientDrawable.$new();
+        bg.setCornerRadius((0, style_1.dp)(ctx, 14));
+        bg.setColor(this.theme.colors.cardBg);
+        bg.setStroke((0, style_1.dp)(ctx, 1), this.theme.colors.divider);
+        panel.setBackgroundDrawable(bg);
+        panel.setPadding((0, style_1.dp)(ctx, 8), (0, style_1.dp)(ctx, 8), (0, style_1.dp)(ctx, 8), (0, style_1.dp)(ctx, 8));
+        try {
+            panel.setTranslationY(this.height);
+        }
+        catch { }
+        try {
+            panel.setElevation(100001);
+        }
+        catch { }
+        try {
+            panel.setTranslationZ(100001);
+        }
+        catch { }
+        const logRoot = this.createLogView();
+        logRoot.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.MATCH_PARENT.value));
+        this.logScrollView = logRoot;
+        panel.addView(logRoot);
+        this.bindLoggerToLogViewOnce();
+        Java.scheduleOnMainThread(() => {
+            try {
+                this.parentView.addView(panel);
+                try {
+                    panel.bringToFront();
+                }
+                catch { }
+            }
+            catch (e) {
+                console.error("ensureLogDrawer failed: " + e);
+            }
+        });
+        this.logDrawerPanel = panel;
+    }
+    openLogDrawer() {
+        if (!this.logDrawerPanel)
+            return;
+        const View = api_1.API.View;
+        this.isLogDrawerOpen = true;
+        Java.scheduleOnMainThread(() => {
+            try {
+                this.logDrawerPanel.setVisibility(View.VISIBLE.value);
+                try {
+                    this.logDrawerPanel.bringToFront();
+                }
+                catch { }
+                try {
+                    this.logDrawerPanel.animate()
+                        .translationY(0)
+                        .setDuration(180)
+                        .start();
+                }
+                catch {
+                    this.logDrawerPanel.setTranslationY(0);
+                }
+            }
+            catch { }
+        });
+    }
+    closeLogDrawer() {
+        const View = api_1.API.View;
+        this.isLogDrawerOpen = false;
+        const endAction = Java.registerClass({
+            name: "LogBottomCloseEnd" +
+                Date.now() +
+                Math.random().toString(36).substring(4),
+            implements: [Java.use("java.lang.Runnable")],
+            methods: {
+                run: () => {
+                    try {
+                        this.logDrawerPanel.setVisibility(View.GONE.value);
+                    }
+                    catch { }
+                },
+            },
+        }).$new();
+        Java.scheduleOnMainThread(() => {
+            try {
+                try {
+                    this.logDrawerPanel.animate()
+                        .translationY(this.height)
+                        .setDuration(160)
+                        .withEndAction(endAction)
+                        .start();
+                }
+                catch {
+                    this.logDrawerPanel.setTranslationY(this.height);
+                    this.logDrawerPanel.setVisibility(View.GONE.value);
+                }
+            }
+            catch { }
+        });
+    }
+    createLogView() {
+        const ScrollView = api_1.API.ScrollView;
+        const TextView = api_1.API.TextView;
+        const ViewGroupLayoutParams = api_1.API.ViewGroupLayoutParams;
+        const LinearLayoutParams = api_1.API.LinearLayoutParams;
+        const JString = api_1.API.JString;
+        const Gravity = api_1.API.Gravity;
+        const sv = ScrollView.$new(this.context);
+        sv.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.MATCH_PARENT.value));
+        try {
+            sv.setFillViewport(true);
+            sv.setVerticalScrollBarEnabled(false);
+            sv.setBackgroundColor(0x00000000);
+        }
+        catch (e) {
+            console.error("createLogView setFillViewport failed: " + e);
+        }
+        const tv = TextView.$new(this.context);
+        tv.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+        tv.setTextColor(this.theme.colors.text);
+        tv.setTextSize(2, this.theme.textSp.body);
+        tv.setGravity(Gravity.START.value);
+        tv.setIncludeFontPadding(false);
+        tv.setPadding((0, style_1.dp)(this.context, 10), (0, style_1.dp)(this.context, 8), (0, style_1.dp)(this.context, 10), (0, style_1.dp)(this.context, 8));
+        tv.setText(JString.$new(""));
+        sv.addView(tv);
+        this.logView = tv;
+        return sv;
+    }
+}
+exports.LogView = LogView;

package/lib/component/views/tabs-view.d.ts

@@ -0,0 +1,35 @@
+import { Logger } from "../../logger";
+import { Theme } from "../style/theme";
+interface TabDefinition {
+    id: string;
+    label: string;
+}
+export declare class TabsView {
+    private context;
+    private parentView;
+    private theme;
+    tabContainer: any;
+    tabs: Map<string, {
+        label: string;
+        container: any;
+        root?: any;
+        scrollView?: any;
+        components: Set<string>;
+    }>;
+    activeTabId: any;
+    tabView: any;
+    menuPanelView: any;
+    logger: Logger;
+    initTabs: TabDefinition[];
+    currentContentContainer: any;
+    currentScrollView: any;
+    private eventEmitter;
+    constructor(context: any, theme: Theme, initTabs: TabDefinition[], activeTabId?: string);
+    createTabView(parentView: any): void;
+    private switchTab;
+    private updateTabStyle;
+    private refreshTabsUI;
+    initializeTabs(): void;
+    private createTabContainer;
+}
+export {};

package/lib/component/views/tabs-view.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TabsView = void 0;
+const api_1 = require("../../api");
+const event_emitter_1 = require("../../event-emitter");
+const logger_1 = require("../../logger");
+const style_1 = require("../style/style");
+class TabsView {
+    constructor(context, theme, initTabs, activeTabId) {
+        this.tabs = new Map();
+        this.logger = logger_1.Logger.instance;
+        this.eventEmitter = new event_emitter_1.EventEmitter();
+        this.context = context;
+        this.theme = theme;
+        this.initTabs = initTabs;
+        this.activeTabId = activeTabId;
+    }
+    createTabView(parentView) {
+        this.parentView = parentView;
+        try {
+            const LinearLayout = api_1.API.LinearLayout;
+            const LinearLayoutParams = api_1.API.LinearLayoutParams;
+            const ViewGroupLayoutParams = api_1.API.ViewGroupLayoutParams;
+            const TextView = api_1.API.TextView;
+            const OnClickListener = api_1.API.OnClickListener;
+            const JString = api_1.API.JString;
+            const HorizontalScrollView = api_1.API.HorizontalScrollView;
+            const GradientDrawable = api_1.API.GradientDrawable;
+            const Gravity = api_1.API.Gravity;
+            const self = this;
+            const scrollView = HorizontalScrollView.$new(this.context);
+            scrollView.setHorizontalScrollBarEnabled(false);
+            scrollView.setScrollbarFadingEnabled(true);
+            scrollView.setFillViewport(true);
+            const scrollLp = LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+            scrollView.setLayoutParams(scrollLp);
+            const bg = GradientDrawable.$new();
+            bg.setCornerRadius((0, style_1.dp)(this.context, 14));
+            bg.setColor(this.theme.colors.cardBg);
+            bg.setStroke((0, style_1.dp)(this.context, 1), this.theme.colors.divider);
+            scrollView.setBackgroundDrawable(bg);
+            scrollView.setPadding((0, style_1.dp)(this.context, 8), (0, style_1.dp)(this.context, 6), (0, style_1.dp)(this.context, 8), (0, style_1.dp)(this.context, 6));
+            const tabContainer = LinearLayout.$new(this.context);
+            tabContainer.setOrientation(0);
+            tabContainer.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.WRAP_CONTENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+            this.tabContainer = tabContainer;
+            const styleTab = (tv, active) => {
+                tv.setAllCaps(false);
+                tv.setSingleLine(true);
+                tv.setGravity(Gravity.CENTER.value);
+                tv.setTextSize(2, this.theme.textSp.body);
+                tv.setPadding((0, style_1.dp)(this.context, 12), (0, style_1.dp)(this.context, 8), (0, style_1.dp)(this.context, 12), (0, style_1.dp)(this.context, 8));
+                const d = GradientDrawable.$new();
+                d.setCornerRadius((0, style_1.dp)(this.context, 12));
+                if (active) {
+                    d.setColor(this.theme.colors.accent);
+                    tv.setTextColor(0xffffffff | 0);
+                }
+                else {
+                    d.setColor(0x00000000);
+                    tv.setTextColor(this.theme.colors.subText);
+                    d.setStroke((0, style_1.dp)(this.context, 1), this.theme.colors.divider);
+                }
+                tv.setBackgroundDrawable(d);
+                try {
+                    tv.setTypeface(null, active ? 1 : 0);
+                }
+                catch (e) { }
+            };
+            for (const [tabId, tabInfo] of this.tabs) {
+                const tabText = TextView.$new(this.context);
+                tabText.setText(JString.$new(tabInfo.label));
+                const btnLp = LinearLayoutParams.$new(ViewGroupLayoutParams.WRAP_CONTENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value);
+                btnLp.setMargins((0, style_1.dp)(this.context, 6), (0, style_1.dp)(this.context, 2), (0, style_1.dp)(this.context, 6), (0, style_1.dp)(this.context, 2));
+                tabText.setLayoutParams(btnLp);
+                styleTab(tabText, tabId === this.activeTabId);
+                const tabClickListener = Java.registerClass({
+                    name: "com.example.TabClickListener" +
+                        Date.now() +
+                        Math.random().toString(36).substring(6) +
+                        "_" +
+                        tabId,
+                    implements: [OnClickListener],
+                    methods: {
+                        onClick: function () {
+                            self.switchTab(tabId);
+                        },
+                    },
+                });
+                tabText.setOnClickListener(tabClickListener.$new());
+                tabContainer.addView(tabText);
+            }
+            scrollView.addView(tabContainer);
+            this.tabView = scrollView;
+            parentView.addView(this.tabView);
+            this.createTabContainer();
+        }
+        catch (error) {
+            this.logger.error("Failed to create tab view: " + error);
+        }
+    }
+    switchTab(tabId) {
+        if (!this.tabs.has(tabId) || tabId === this.activeTabId)
+            return;
+        const oldTabId = this.activeTabId;
+        this.activeTabId = tabId;
+        this.refreshTabsUI();
+        Java.scheduleOnMainThread(() => {
+            try {
+                const View = api_1.API.View;
+                for (const [id, tabInfo] of this.tabs) {
+                    const root = tabInfo.root;
+                    if (!root)
+                        continue;
+                    if (id === tabId) {
+                        root.setVisibility(View.VISIBLE.value);
+                        this.currentContentContainer = tabInfo.container;
+                        this.currentScrollView = tabInfo.scrollView;
+                    }
+                    else {
+                        root.setVisibility(View.GONE.value);
+                    }
+                }
+                if (this.tabContainer) {
+                    const tabIds = Array.from(this.tabs.keys());
+                    const childCount = this.tabContainer.getChildCount();
+                    for (let i = 0; i < childCount && i < tabIds.length; i++) {
+                        const tv = Java.cast(this.tabContainer.getChildAt(i), api_1.API.TextView);
+                        this.updateTabStyle(tv, tabIds[i] === tabId);
+                    }
+                }
+                this.eventEmitter.emit("tabChanged", tabId, oldTabId);
+            }
+            catch (error) {
+                console.error(`Failed to switch to tab ${tabId}:`, error);
+            }
+        });
+    }
+    updateTabStyle(button, isActive) {
+        const GradientDrawable = api_1.API.GradientDrawable;
+        const ctx = button.getContext();
+        const radius = (0, style_1.dp)(ctx, 12);
+        const strokeW = (0, style_1.dp)(ctx, 1);
+        const padH = (0, style_1.dp)(ctx, 12);
+        const padV = (0, style_1.dp)(ctx, 8);
+        try {
+            button.setAllCaps(false);
+        }
+        catch (e) { }
+        button.setSingleLine(true);
+        button.setTextSize(2, this.theme.textSp.body);
+        button.setPadding(padH, padV, padH, padV);
+        const drawable = GradientDrawable.$new();
+        drawable.setCornerRadius(radius);
+        if (isActive) {
+            drawable.setColor(this.theme.colors.accent);
+            button.setTextColor(0xffffffff | 0);
+            try {
+                button.setTypeface(null, 1);
+            }
+            catch (e) { }
+        }
+        else {
+            drawable.setColor(0x00000000);
+            drawable.setStroke(strokeW, this.theme.colors.divider);
+            button.setTextColor(this.theme.colors.subText);
+            try {
+                button.setTypeface(null, 0);
+            }
+            catch (e) { }
+        }
+        button.setBackgroundDrawable(drawable);
+    }
+    refreshTabsUI() {
+        try {
+            if (!this.tabContainer)
+                return;
+            const GradientDrawable = api_1.API.GradientDrawable;
+            const count = this.tabContainer.getChildCount();
+            const tabIds = Array.from(this.tabs.keys());
+            for (let i = 0; i < count; i++) {
+                const tv = this.tabContainer.getChildAt(i);
+                const tabId = tabIds[i];
+                const active = tabId === this.activeTabId;
+                const d = GradientDrawable.$new();
+                d.setCornerRadius((0, style_1.dp)(this.context, 12));
+                if (active) {
+                    d.setColor(this.theme.colors.accent);
+                    tv.setTextColor(0xffffffff | 0);
+                    try {
+                        tv.setTypeface(null, 1);
+                    }
+                    catch (e) { }
+                }
+                else {
+                    d.setColor(0x00000000);
+                    d.setStroke((0, style_1.dp)(this.context, 1), this.theme.colors.divider);
+                    tv.setTextColor(this.theme.colors.subText);
+                    try {
+                        tv.setTypeface(null, 0);
+                    }
+                    catch (e) { }
+                }
+                tv.setBackgroundDrawable(d);
+            }
+        }
+        catch (e) { }
+    }
+    initializeTabs() {
+        this.tabs.clear();
+        if (this.initTabs && this.initTabs.length > 0) {
+            for (const tabDef of this.initTabs) {
+                this.tabs.set(tabDef.id, {
+                    label: tabDef.label,
+                    container: null,
+                    components: new Set(),
+                });
+            }
+            if (this.activeTabId && this.tabs.has(this.activeTabId)) {
+                this.activeTabId = this.activeTabId;
+            }
+            else if (this.initTabs.length > 0) {
+                this.activeTabId = this.initTabs[0].id;
+            }
+        }
+        else {
+            this.tabs.set("default", {
+                label: "Default",
+                container: null,
+                components: new Set(),
+            });
+            this.activeTabId = "default";
+        }
+    }
+    createTabContainer() {
+        const ScrollView = api_1.API.ScrollView;
+        const LinearLayout = api_1.API.LinearLayout;
+        const ViewGroupLayoutParams = api_1.API.ViewGroupLayoutParams;
+        const LinearLayoutParams = api_1.API.LinearLayoutParams;
+        const View = api_1.API.View;
+        const tabRootsWrapper = LinearLayout.$new(this.context);
+        tabRootsWrapper.setOrientation(LinearLayout.VERTICAL.value);
+        tabRootsWrapper.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+        if (!this.tabs || this.tabs.size === 0) {
+            console.warn("[FloatMenu] tabs is empty, tab container will be blank.");
+        }
+        let firstTabId = null;
+        let firstTabInfo = null;
+        for (const [tabId, tabInfo] of this.tabs) {
+            if (!firstTabId) {
+                firstTabId = tabId;
+                firstTabInfo = tabInfo;
+            }
+            const sv = ScrollView.$new(this.context);
+            sv.setLayoutParams(LinearLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, 0, 1.0));
+            try {
+                sv.setBackgroundColor(0x00000000);
+            }
+            catch (e) { }
+            try {
+                sv.setFillViewport(true);
+                sv.setVerticalScrollBarEnabled(false);
+            }
+            catch (e) { }
+            const tabContainer = LinearLayout.$new(this.context);
+            tabContainer.setOrientation(LinearLayout.VERTICAL.value);
+            tabContainer.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.WRAP_CONTENT.value));
+            tabContainer.setPadding((0, style_1.dp)(this.context, 10), (0, style_1.dp)(this.context, 10), (0, style_1.dp)(this.context, 10), (0, style_1.dp)(this.context, 10));
+            tabContainer.setPadding(0, 0, 0, (0, style_1.dp)(this.context, 4));
+            sv.addView(tabContainer);
+            if (tabId === this.activeTabId) {
+                sv.setVisibility(View.VISIBLE.value);
+                this.currentContentContainer = tabContainer;
+                this.currentScrollView = sv;
+            }
+            else {
+                sv.setVisibility(View.GONE.value);
+            }
+            tabInfo.container = tabContainer;
+            tabInfo.scrollView = sv;
+            tabInfo.root = sv;
+            tabRootsWrapper.addView(sv);
+        }
+        if ((!this.currentContentContainer || !this.currentScrollView) &&
+            firstTabId &&
+            firstTabInfo) {
+            this.activeTabId = firstTabId;
+            if (firstTabInfo.root)
+                firstTabInfo.root.setVisibility(View.VISIBLE.value);
+            this.currentContentContainer = firstTabInfo.container;
+            this.currentScrollView = firstTabInfo.scrollView;
+        }
+        this.parentView.addView(tabRootsWrapper);
+    }
+}
+exports.TabsView = TabsView;

package/lib/event-emitter.d.ts

@@ -0,0 +1,10 @@
+type Listener = (...args: any[]) => void;
+export declare class EventEmitter {
+    private events;
+    on(event: string, listener: Listener): void;
+    off(event: string, listener: Listener): void;
+    emit(event: string, ...args: any[]): void;
+    once(event: string, listener: Listener): void;
+    removeAllListeners(event?: string): void;
+}
+export {};

package/lib/event-emitter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+class EventEmitter {
+    constructor() {
+        this.events = new Map();
+    }
+    on(event, listener) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+        this.events.get(event).push(listener);
+    }
+    off(event, listener) {
+        const listeners = this.events.get(event);
+        if (!listeners)
+            return;
+        const index = listeners.indexOf(listener);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+        }
+    }
+    emit(event, ...args) {
+        const listeners = this.events.get(event);
+        if (!listeners)
+            return;
+        listeners.forEach((listener) => {
+            try {
+                setImmediate(() => listener(...args));
+            }
+            catch (error) {
+                console.error(`Error in event listener for ${event}:`, error);
+            }
+        });
+    }
+    once(event, listener) {
+        const onceWrapper = (...args) => {
+            this.off(event, onceWrapper);
+            listener(...args);
+        };
+        this.on(event, onceWrapper);
+    }
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        }
+        else {
+            this.events.clear();
+        }
+    }
+}
+exports.EventEmitter = EventEmitter;

package/lib/float-menu.d.ts

@@ -0,0 +1,63 @@
+import { UIComponent } from "./component/ui-components";
+import { Logger } from "./logger";
+import { Theme } from "./component/style/theme";
+export interface TabDefinition {
+    id: string;
+    label: string;
+}
+export interface FloatMenuOptions {
+    width?: number;
+    height?: number;
+    x?: number;
+    y?: number;
+    iconWidth?: number;
+    iconHeight?: number;
+    iconBase64?: string;
+    logMaxLines?: number;
+    theme?: Theme;
+    title?: string;
+    tabs?: TabDefinition[];
+    activeTab?: string;
+}
+export declare class FloatMenu {
+    options: FloatMenuOptions;
+    private headerView;
+    private iconView;
+    private uiComponents;
+    private pendingComponents;
+    private eventEmitter;
+    private isIconMode;
+    private _context;
+    private lastTouchX;
+    private lastTouchY;
+    private screenWidth;
+    private screenHeight;
+    private menuWindowParams;
+    private iconWindowParams;
+    private iconContainerWin;
+    private menuContainerWin;
+    private menuPanelView;
+    logger: Logger;
+    private logPanelView;
+    private tabsView;
+    get context(): any;
+    private _windowManager;
+    get windowManager(): any;
+    constructor(options?: FloatMenuOptions);
+    private addDragListener;
+    private createMenuContainerWindow;
+    private updatePosition;
+    private createIconWindow;
+    toggleView(): void;
+    show(): void;
+    private processPendingComponents;
+    hide(): void;
+    toast(msg: string, duration?: 0 | 1): void;
+    addComponent(component: UIComponent, tabId?: string): void;
+    removeComponent(id: string): void;
+    getComponent<T extends UIComponent>(id: string): T | undefined;
+    setComponentValue(id: string, value: any): void;
+    on(event: string, callback: (...args: any[]) => void): void;
+    off(event: string, callback: (...args: any[]) => void): void;
+    private createHeaderView;
+}