frida-float-menu 1.0.0

package/lib/float-menu.js

@@ -0,0 +1,568 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatMenu = void 0;
+const event_emitter_1 = require("./event-emitter");
+const logger_1 = require("./logger");
+const api_1 = require("./api");
+const style_1 = require("./component/style/style");
+const theme_1 = require("./component/style/theme");
+const log_view_1 = require("./component/views/log-view");
+const utils_1 = require("./utils");
+const tabs_view_1 = require("./component/views/tabs-view");
+class FloatMenu {
+    get context() {
+        if (this._context === null) {
+            this._context = Java.use("android.app.ActivityThread")
+                .currentApplication()
+                .getApplicationContext();
+        }
+        return this._context;
+    }
+    get windowManager() {
+        if (this._windowManager === null) {
+            const Context = api_1.API.Context;
+            this._windowManager = Java.cast(this.context.getSystemService(Context.WINDOW_SERVICE.value), api_1.API.ViewManager);
+        }
+        return this._windowManager;
+    }
+    constructor(options = {}) {
+        this.uiComponents = new Map();
+        this.pendingComponents = [];
+        this.eventEmitter = new event_emitter_1.EventEmitter();
+        this.isIconMode = true;
+        this._context = null;
+        this._windowManager = null;
+        this.options = {
+            width: 1000,
+            height: 900,
+            x: 0,
+            y: 0,
+            iconWidth: 200,
+            iconHeight: 200,
+            logMaxLines: 100,
+            title: "Frida Float Menu",
+            theme: theme_1.DarkNeonTheme,
+            tabs: [],
+            activeTab: undefined,
+            ...options,
+        };
+        this.logger = logger_1.Logger.instance;
+        Java.perform(() => {
+            const resources = this.context.getResources();
+            const metrics = resources.getDisplayMetrics();
+            this.screenWidth = metrics.widthPixels.value;
+            this.screenHeight = metrics.heightPixels.value;
+            this.options.height = Math.min(this.options.height, this.screenHeight - 80);
+        });
+        this.logger.info("屏幕尺寸:", this.screenWidth, this.screenHeight);
+        this.tabsView = new tabs_view_1.TabsView(this.context, this.options.theme, this.options.tabs, this.options.activeTab);
+        this.tabsView.initializeTabs();
+        this.logger.info("悬浮窗初始化完成,等待显示");
+    }
+    addDragListener(targetView, window, winParams) {
+        const OnTouchListener = api_1.API.OnTouchListener;
+        const MotionEvent = api_1.API.MotionEvent;
+        targetView.setClickable(true);
+        const getBounds = () => {
+            const w = this.isIconMode ? this.options.iconWidth : this.options.width;
+            const h = this.isIconMode
+                ? this.options.iconHeight
+                : this.options.height;
+            return {
+                left: 0,
+                top: -40,
+                right: this.screenWidth - w,
+                bottom: this.screenHeight - h,
+            };
+        };
+        const self = this;
+        let isDragging = false;
+        const DRAG_THRESHOLD = 5;
+        let touchOffsetX = 0;
+        let touchOffsetY = 0;
+        const touchListener = Java.registerClass({
+            name: "com.frida.FloatDragListener" +
+                Date.now() +
+                Math.random().toString(36).substring(6),
+            implements: [OnTouchListener],
+            methods: {
+                onTouch: function (v, event) {
+                    const action = event.getAction();
+                    switch (action) {
+                        case MotionEvent.ACTION_DOWN.value: {
+                            isDragging = false;
+                            const rawX = event.getRawX();
+                            const rawY = event.getRawY();
+                            const startWx = winParams.x.value;
+                            const startWy = winParams.y.value;
+                            touchOffsetX = rawX - startWx;
+                            touchOffsetY = rawY - startWy;
+                            self.lastTouchX = rawX;
+                            self.lastTouchY = rawY;
+                            return true;
+                        }
+                        case MotionEvent.ACTION_MOVE.value: {
+                            const rawX = event.getRawX();
+                            const rawY = event.getRawY();
+                            const dx = rawX - self.lastTouchX;
+                            const dy = rawY - self.lastTouchY;
+                            if (!isDragging &&
+                                (Math.abs(dx) > DRAG_THRESHOLD || Math.abs(dy) > DRAG_THRESHOLD)) {
+                                isDragging = true;
+                            }
+                            if (isDragging) {
+                                let wx = rawX - touchOffsetX;
+                                let wy = rawY - touchOffsetY;
+                                const p = (0, utils_1.windowToLogical)(wx, wy, self.screenWidth, self.screenHeight, self.isIconMode
+                                    ? self.options.iconWidth
+                                    : self.options.width, self.isIconMode
+                                    ? self.options.iconHeight
+                                    : self.options.height);
+                                let newX = p.x;
+                                let newY = p.y;
+                                const bounds = getBounds();
+                                newX = Math.max(bounds.left, Math.min(bounds.right, newX));
+                                newY = Math.max(bounds.top, Math.min(bounds.bottom, newY));
+                                self.updatePosition(window, winParams, { x: newX, y: newY });
+                            }
+                            return true;
+                        }
+                        case MotionEvent.ACTION_UP.value:
+                        case MotionEvent.ACTION_CANCEL.value: {
+                            if (!isDragging) {
+                                try {
+                                    self.isIconMode = false;
+                                    self.iconContainerWin.setAlpha(1);
+                                    self.toggleView();
+                                }
+                                catch { }
+                            }
+                            return true;
+                        }
+                    }
+                },
+            },
+        });
+        targetView.setOnTouchListener(touchListener.$new());
+    }
+    createMenuContainerWindow() {
+        const FrameLayout = api_1.API.FrameLayout;
+        const LinearLayout = api_1.API.LinearLayout;
+        const FrameLayoutParams = api_1.API.FrameLayoutParams;
+        const ViewGroupLayoutParams = api_1.API.ViewGroupLayoutParams;
+        const View = api_1.API.View;
+        const LayoutParams = api_1.API.LayoutParams;
+        this.menuContainerWin = FrameLayout.$new(this.context);
+        const rootLp = FrameLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.MATCH_PARENT.value);
+        rootLp.gravity = api_1.API.Gravity.TOP.value | api_1.API.Gravity.START.value;
+        this.menuContainerWin.setLayoutParams(rootLp);
+        try {
+            this.menuContainerWin.setBackgroundColor(0x00000000);
+        }
+        catch (e) { }
+        const panel = LinearLayout.$new(this.context);
+        panel.setOrientation(LinearLayout.VERTICAL.value);
+        panel.setLayoutParams(ViewGroupLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.MATCH_PARENT.value));
+        (0, style_1.applyStyle)(panel, "overlay", this.options.theme);
+        try {
+            panel.setClipToOutline(true);
+        }
+        catch (e) { }
+        try {
+            panel.setClipChildren(false);
+        }
+        catch (e) { }
+        try {
+            panel.setClipToPadding(false);
+        }
+        catch (e) { }
+        this.menuPanelView = panel;
+        const overlay = FrameLayout.$new(this.context);
+        overlay.setLayoutParams(FrameLayoutParams.$new(ViewGroupLayoutParams.MATCH_PARENT.value, ViewGroupLayoutParams.MATCH_PARENT.value));
+        try {
+            overlay.setClipChildren(false);
+        }
+        catch (e) { }
+        try {
+            overlay.setClipToPadding(false);
+        }
+        catch (e) { }
+        try {
+            overlay.setElevation(100000);
+        }
+        catch (e) { }
+        try {
+            overlay.setTranslationZ(100000);
+        }
+        catch (e) { }
+        this.logPanelView = overlay;
+        this.menuContainerWin.addView(panel);
+        this.menuContainerWin.addView(overlay);
+        this.menuWindowParams = LayoutParams.$new(this.options.width, this.options.height, 0, 0, 2038, LayoutParams.FLAG_NOT_FOCUSABLE.value |
+            LayoutParams.FLAG_NOT_TOUCH_MODAL.value, 1);
+        this.createHeaderView(this.context);
+        this.tabsView.createTabView(this.menuPanelView);
+        this.windowManager.addView(this.menuContainerWin, this.menuWindowParams);
+        this.menuContainerWin.setVisibility(View.GONE.value);
+    }
+    updatePosition(window, winParams, newPos) {
+        const { x: wx, y: wy } = (0, utils_1.logicalToWindow)(newPos.x, newPos.y, this.screenWidth, this.screenHeight, this.isIconMode ? this.options.iconWidth : this.options.width, this.isIconMode ? this.options.iconHeight : this.options.height);
+        winParams.x.value = wx | 0;
+        winParams.y.value = wy | 0;
+        Java.scheduleOnMainThread(() => {
+            this.windowManager.updateViewLayout(window, winParams);
+        });
+    }
+    createIconWindow() {
+        const ImageView = api_1.API.ImageView;
+        const ImageView$ScaleType = api_1.API.ImageViewScaleType;
+        const FrameLayoutParams = api_1.API.FrameLayoutParams;
+        const Gravity = api_1.API.Gravity;
+        const LayoutParams = api_1.API.LayoutParams;
+        const BitmapFactory = api_1.API.BitmapFactory;
+        const Base64 = api_1.API.Base64;
+        const FrameLayout = api_1.API.FrameLayout;
+        this.iconView = ImageView.$new(this.context);
+        if (this.options.iconBase64) {
+            const decoded = Base64.decode(this.options.iconBase64, Base64.DEFAULT.value);
+            const bitmap = BitmapFactory.decodeByteArray(decoded, 0, decoded.length);
+            this.iconView.setImageBitmap(bitmap);
+        }
+        else {
+            this.iconView.setBackgroundColor(0xff4285f4 | 0);
+            try {
+                this.iconView.setClipToOutline(true);
+            }
+            catch { }
+        }
+        this.iconView.setScaleType(ImageView$ScaleType.FIT_CENTER.value);
+        const { x, y } = (0, utils_1.logicalToWindow)(this.options.x, this.options.y, this.screenWidth, this.screenHeight, this.options.iconWidth, this.options.iconHeight);
+        this.iconWindowParams = LayoutParams.$new(this.options.iconWidth, this.options.iconHeight, x, y, 2038, LayoutParams.FLAG_NOT_FOCUSABLE.value |
+            LayoutParams.FLAG_NOT_TOUCH_MODAL.value, 1);
+        this.iconContainerWin = FrameLayout.$new(this.context);
+        this.iconContainerWin.setLayoutParams(FrameLayoutParams.$new(this.options.iconWidth, this.options.iconHeight, Gravity.CENTER.value));
+        this.iconContainerWin.addView(this.iconView);
+        this.windowManager.addView(this.iconContainerWin, this.iconWindowParams);
+        this.addDragListener(this.iconContainerWin, this.iconContainerWin, this.iconWindowParams);
+    }
+    toggleView() {
+        Java.scheduleOnMainThread(() => {
+            const View = api_1.API.View;
+            if (this.isIconMode) {
+                this.menuContainerWin.setVisibility(View.GONE.value);
+                this.iconContainerWin.setVisibility(View.VISIBLE.value);
+            }
+            else {
+                this.menuContainerWin.setVisibility(View.VISIBLE.value);
+                this.iconContainerWin.setVisibility(View.GONE.value);
+            }
+        });
+    }
+    show() {
+        Java.scheduleOnMainThread(() => {
+            const Settings = Java.use("android.provider.Settings");
+            if (!Settings.canDrawOverlays(this.context)) {
+                this.toast("进程没有悬浮窗权限!");
+                console.error("Draw overlays permission not granted");
+                return;
+            }
+            try {
+                this.createIconWindow();
+                this.createMenuContainerWindow();
+                this.processPendingComponents(this.context);
+            }
+            catch (error) {
+                console.error("Failed to show floating window: ", error);
+            }
+        });
+    }
+    processPendingComponents(context) {
+        if (this.pendingComponents.length === 0)
+            return;
+        this.logger.debug(`Processing ${this.pendingComponents.length} pending components`);
+        for (const { id, component, tabId } of this.pendingComponents) {
+            try {
+                const tabInfo = this.tabsView.tabs.get(tabId);
+                if (!tabInfo) {
+                    this.logger.error(`Cannot add pending component ${id} - tab ${tabId} not found`);
+                    continue;
+                }
+                component.init(context);
+                const view = component.getView();
+                if (tabInfo.container) {
+                    tabInfo.container.addView(view);
+                }
+                else {
+                    this.tabsView.currentContentContainer.addView(view);
+                }
+                tabInfo.components.add(id);
+                component.on("valueChanged", (value) => {
+                    this.eventEmitter.emit("component:" + id + ":valueChanged", value);
+                });
+                component.on("action", (data) => {
+                    this.eventEmitter.emit("component:" + id + ":action", data);
+                });
+                component.on("click", (data) => {
+                    this.eventEmitter.emit("component:" + id + ":click", data);
+                });
+            }
+            catch (error) {
+                console.error(`Failed to add pending component ${id}: ` + error);
+            }
+        }
+        this.pendingComponents = [];
+    }
+    hide() {
+        Java.scheduleOnMainThread(() => {
+            try {
+                this.iconContainerWin.setAlpha(0);
+                this.windowManager.updateViewLayout(this.iconContainerWin, this.iconWindowParams);
+            }
+            catch (error) {
+                console.error("Failed to hide floating window: " + error);
+            }
+        });
+    }
+    toast(msg, duration = 0) {
+        Java.scheduleOnMainThread(() => {
+            var toast = Java.use("android.widget.Toast");
+            toast
+                .makeText(this.context, Java.use("java.lang.String").$new(msg), duration)
+                .show();
+        });
+    }
+    addComponent(component, tabId) {
+        const id = component.getId();
+        const targetTabId = tabId || this.tabsView.activeTabId;
+        const tabInfo = this.tabsView.tabs.get(targetTabId);
+        if (!tabInfo) {
+            console.error(`Cannot add component ${id} - tab ${targetTabId} not found`);
+            return;
+        }
+        this.uiComponents.set(id, component);
+        component.setMenu(this);
+        tabInfo.components.add(id);
+        if (!this.menuPanelView) {
+            this.pendingComponents.push({ id, component, tabId: targetTabId });
+            console.debug(`Component ${id} queued for tab ${targetTabId} (window not shown)`);
+            return;
+        }
+        Java.scheduleOnMainThread(() => {
+            const context = this.menuPanelView.getContext();
+            component.init(context);
+            const view = component.getView();
+            if (tabInfo.container) {
+                tabInfo.container.addView(view);
+            }
+            else {
+                console.warn(`Tab container for ${targetTabId} not found, using contentContainer`);
+                this.tabsView.currentContentContainer.addView(view);
+            }
+            component.on("valueChanged", (value) => {
+                this.eventEmitter.emit("component:" + id + ":valueChanged", value);
+            });
+            component.on("action", (data) => {
+                this.eventEmitter.emit("component:" + id + ":action", data);
+            });
+            component.on("click", (data) => {
+                this.eventEmitter.emit("component:" + id + ":click", data);
+            });
+        });
+    }
+    removeComponent(id) {
+        const component = this.uiComponents.get(id);
+        if (!component)
+            return;
+        let targetTabId = null;
+        for (const [tabId, tabInfo] of this.tabsView.tabs) {
+            if (tabInfo.components.has(id)) {
+                targetTabId = tabId;
+                break;
+            }
+        }
+        this.pendingComponents = this.pendingComponents.filter((p) => p.id !== id);
+        Java.scheduleOnMainThread(() => {
+            const view = component.getView();
+            if (targetTabId) {
+                const tabInfo = this.tabsView.tabs.get(targetTabId);
+                if (tabInfo && tabInfo.container) {
+                    try {
+                        tabInfo.container.removeView(view);
+                    }
+                    catch (e) {
+                        if (this.tabsView.currentContentContainer) {
+                            try {
+                                this.tabsView.currentContentContainer.removeView(view);
+                            }
+                            catch (e2) {
+                            }
+                        }
+                    }
+                }
+                else if (this.tabsView.currentContentContainer) {
+                    try {
+                        this.tabsView.currentContentContainer.removeView(view);
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+            else {
+                if (this.tabsView.currentContentContainer) {
+                    try {
+                        this.tabsView.currentContentContainer.removeView(view);
+                    }
+                    catch (e) {
+                        this.menuContainerWin.removeView(view);
+                    }
+                }
+                else if (this.menuContainerWin) {
+                    this.menuContainerWin.removeView(view);
+                }
+                else
+                    console.error("error");
+            }
+        });
+        if (targetTabId) {
+            const tabInfo = this.tabsView.tabs.get(targetTabId);
+            if (tabInfo) {
+                tabInfo.components.delete(id);
+            }
+        }
+        this.uiComponents.delete(id);
+        console.debug(`Component ${id} removed${targetTabId ? ` from tab ${targetTabId}` : ""}`);
+    }
+    getComponent(id) {
+        return this.uiComponents.get(id);
+    }
+    setComponentValue(id, value) {
+        const component = this.uiComponents.get(id);
+        if (component) {
+            component.setValue(value);
+        }
+    }
+    on(event, callback) {
+        this.eventEmitter.on(event, callback);
+    }
+    off(event, callback) {
+        this.eventEmitter.off(event, callback);
+    }
+    createHeaderView(context) {
+        try {
+            const LinearLayout = api_1.API.LinearLayout;
+            const LinearLayoutParams = api_1.API.LinearLayoutParams;
+            const TextView = api_1.API.TextView;
+            const JString = api_1.API.JString;
+            const GradientDrawable = api_1.API.GradientDrawable;
+            const Gravity = api_1.API.Gravity;
+            const self = this;
+            const PAD_H = (0, style_1.dp)(context, 10);
+            const PAD_V = (0, style_1.dp)(context, 8);
+            const BTN_SIZE = (0, style_1.dp)(context, 34);
+            const BTN_RADIUS = (0, style_1.dp)(context, 10);
+            const createIconCharBtn = (ch, isDanger = false) => {
+                const btn = TextView.$new(context);
+                btn.setText(JString.$new(ch));
+                btn.setGravity(Gravity.CENTER.value);
+                btn.setSingleLine(true);
+                btn.setTextSize(2, this.options.theme.textSp.title);
+                btn.setTextColor(isDanger
+                    ? this.options.theme.colors.accent
+                    : this.options.theme.colors.text);
+                const lp = LinearLayoutParams.$new(BTN_SIZE, BTN_SIZE);
+                btn.setLayoutParams(lp);
+                const d = GradientDrawable.$new();
+                d.setCornerRadius(BTN_RADIUS);
+                d.setColor(0x00000000);
+                d.setStroke((0, style_1.dp)(context, 1), this.options.theme.colors.divider);
+                btn.setBackgroundDrawable(d);
+                btn.setPadding((0, style_1.dp)(context, 6), (0, style_1.dp)(context, 6), (0, style_1.dp)(context, 6), (0, style_1.dp)(context, 6));
+                return btn;
+            };
+            this.headerView = LinearLayout.$new(context);
+            this.headerView.setOrientation(0);
+            this.headerView.setGravity(Gravity.CENTER_VERTICAL.value);
+            const headerLp = LinearLayoutParams.$new(LinearLayoutParams.MATCH_PARENT.value, LinearLayoutParams.WRAP_CONTENT.value);
+            this.headerView.setLayoutParams(headerLp);
+            this.headerView.setPadding(PAD_H, PAD_V, PAD_H, PAD_V);
+            const bg = GradientDrawable.$new();
+            bg.setCornerRadius((0, style_1.dp)(context, 14));
+            bg.setColor(this.options.theme.colors.cardBg);
+            bg.setStroke((0, style_1.dp)(context, 1), this.options.theme.colors.divider);
+            this.headerView.setBackgroundDrawable(bg);
+            const titleView = TextView.$new(context);
+            titleView.setText(JString.$new(this.options.title));
+            titleView.setSingleLine(true);
+            titleView.setGravity(Gravity.CENTER_VERTICAL.value);
+            titleView.setTypeface(null, 1);
+            titleView.setTextColor(this.options.theme.colors.text);
+            titleView.setTextSize(2, this.options.theme.textSp.title);
+            const titleLp = LinearLayoutParams.$new(0, LinearLayoutParams.WRAP_CONTENT.value, 1.0);
+            titleView.setLayoutParams(titleLp);
+            titleView.setPadding(0, (0, style_1.dp)(context, 2), (0, style_1.dp)(context, 10), (0, style_1.dp)(context, 2));
+            const rightBox = LinearLayout.$new(context);
+            rightBox.setOrientation(0);
+            rightBox.setGravity(Gravity.CENTER_VERTICAL.value);
+            const rightLp = LinearLayoutParams.$new(LinearLayoutParams.WRAP_CONTENT.value, LinearLayoutParams.WRAP_CONTENT.value);
+            rightBox.setLayoutParams(rightLp);
+            const logView = new log_view_1.LogView(context, this.options.height - 240, this.options.theme, this.options.logMaxLines);
+            const logButton = createIconCharBtn("L", false);
+            logButton.setOnClickListener(Java.registerClass({
+                name: "LogButtonClickListener" + Date.now(),
+                implements: [api_1.API.OnClickListener],
+                methods: {
+                    onClick: function () {
+                        logView.createViewOnce(self.logPanelView);
+                        if (logView.isLogDrawerOpen) {
+                            logView.closeLogDrawer();
+                            logButton.setText(api_1.API.JString.$new("L"));
+                        }
+                        else {
+                            logView.openLogDrawer();
+                            logButton.setText(api_1.API.JString.$new("←"));
+                        }
+                    },
+                },
+            }).$new());
+            const minButton = createIconCharBtn("—", false);
+            minButton.setOnClickListener(Java.registerClass({
+                name: "MinButtonClickListener" + Date.now(),
+                implements: [api_1.API.OnClickListener],
+                methods: {
+                    onClick: function () {
+                        self.isIconMode = true;
+                        self.toggleView();
+                    },
+                },
+            }).$new());
+            const hideButton = createIconCharBtn("X", true);
+            hideButton.setOnClickListener(Java.registerClass({
+                name: "HideButtonClickListener" + Date.now(),
+                implements: [api_1.API.OnClickListener],
+                methods: {
+                    onClick: function () {
+                        self.isIconMode = true;
+                        self.toggleView();
+                        self.hide();
+                        self.toast("菜单已隐藏,单击原来位置显示");
+                    },
+                },
+            }).$new());
+            const lpBtn = LinearLayoutParams.$new(BTN_SIZE, BTN_SIZE);
+            lpBtn.setMargins(0, 0, (0, style_1.dp)(context, 8), 0);
+            logButton.setLayoutParams(lpBtn);
+            minButton.setLayoutParams(lpBtn);
+            rightBox.addView(logButton);
+            rightBox.addView(minButton);
+            rightBox.addView(hideButton);
+            this.headerView.addView(titleView);
+            this.headerView.addView(rightBox);
+            this.menuPanelView.addView(this.headerView);
+            this.addDragListener(this.headerView, this.menuContainerWin, this.menuWindowParams);
+        }
+        catch (error) {
+            console.error("Failed to create header view: " + error);
+        }
+    }
+}
+exports.FloatMenu = FloatMenu;

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export { EventEmitter } from "./event-emitter";
+export { Logger, LogLevel } from "./logger";
+export { Button } from "./component/button";
+export { Category } from "./component/category";
+export { Collapsible } from "./component/collapsible";
+export { NumberInput, TextInput } from "./component/input";
+export { Selector } from "./component/selector";
+export { Slider } from "./component/slider";
+export { Switch } from "./component/switch";
+export { TextView as Text } from "./component/text";
+export { ImageView } from "./component/image";
+export { FloatMenu, FloatMenuOptions, TabDefinition } from "./float-menu";

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatMenu = exports.ImageView = exports.Text = exports.Switch = exports.Slider = exports.Selector = exports.TextInput = exports.NumberInput = exports.Collapsible = exports.Category = exports.Button = exports.Logger = exports.EventEmitter = void 0;
+var event_emitter_1 = require("./event-emitter");
+Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return event_emitter_1.EventEmitter; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+var button_1 = require("./component/button");
+Object.defineProperty(exports, "Button", { enumerable: true, get: function () { return button_1.Button; } });
+var category_1 = require("./component/category");
+Object.defineProperty(exports, "Category", { enumerable: true, get: function () { return category_1.Category; } });
+var collapsible_1 = require("./component/collapsible");
+Object.defineProperty(exports, "Collapsible", { enumerable: true, get: function () { return collapsible_1.Collapsible; } });
+var input_1 = require("./component/input");
+Object.defineProperty(exports, "NumberInput", { enumerable: true, get: function () { return input_1.NumberInput; } });
+Object.defineProperty(exports, "TextInput", { enumerable: true, get: function () { return input_1.TextInput; } });
+var selector_1 = require("./component/selector");
+Object.defineProperty(exports, "Selector", { enumerable: true, get: function () { return selector_1.Selector; } });
+var slider_1 = require("./component/slider");
+Object.defineProperty(exports, "Slider", { enumerable: true, get: function () { return slider_1.Slider; } });
+var switch_1 = require("./component/switch");
+Object.defineProperty(exports, "Switch", { enumerable: true, get: function () { return switch_1.Switch; } });
+var text_1 = require("./component/text");
+Object.defineProperty(exports, "Text", { enumerable: true, get: function () { return text_1.TextView; } });
+var image_1 = require("./component/image");
+Object.defineProperty(exports, "ImageView", { enumerable: true, get: function () { return image_1.ImageView; } });
+var float_menu_1 = require("./float-menu");
+Object.defineProperty(exports, "FloatMenu", { enumerable: true, get: function () { return float_menu_1.FloatMenu; } });

package/lib/logger.d.ts

@@ -0,0 +1,43 @@
+export declare function log(message: string): void;
+export type LogLevel = "debug" | "info" | "warn" | "error" | "none";
+type LogItem = {
+    ts: number;
+    level: LogLevel;
+    message: string;
+};
+type LogListener = (items: LogItem[]) => void;
+export declare class Logger {
+    on(arg0: string, arg1: (level: LogLevel, message: string) => void): void;
+    private static _instance;
+    static get instance(): Logger;
+    private levelPriority;
+    private currentLevel;
+    private maxBuffer;
+    private buffer;
+    private head;
+    private size;
+    private flushIntervalMs;
+    private pending;
+    private flushTimer;
+    private listeners;
+    constructor(level?: LogLevel, options?: {
+        maxBuffer?: number;
+        flushIntervalMs?: number;
+    });
+    setLevel(level: LogLevel): void;
+    setMaxBuffer(max: number): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    onLog(listener: LogListener, replay?: boolean): () => void;
+    getRecent(limit?: number): LogItem[];
+    clear(): void;
+    private safeStringify;
+    private formatArgs;
+    private _log;
+    private pushToBuffer;
+    private scheduleFlush;
+    private emitBatch;
+}
+export {};