6 |
7 |
8 | );
9 | }
10 |
--------------------------------------------------------------------------------
/src/main/ipc/app/actions.ts:
--------------------------------------------------------------------------------
1 | import { BrowserWindow } from "@/controllers/windows-controller/types";
2 | import { sendMessageToListeners } from "@/ipc/listeners-manager";
3 |
4 | export async function fireCopyLinkAction(win: BrowserWindow) {
5 | win.sendMessage("actions:on-copy-link");
6 | }
7 |
8 | export async function fireFrontendAction(action: string) {
9 | sendMessageToListeners("actions:on-incoming", action);
10 | }
11 |
--------------------------------------------------------------------------------
/src/main/ipc/app/open-external.ts:
--------------------------------------------------------------------------------
1 | import { getAlwaysOpenExternal, unsetAlwaysOpenExternal } from "@/saving/open-external";
2 | import { ipcMain } from "electron";
3 |
4 | ipcMain.handle("open-external:get", () => {
5 | return getAlwaysOpenExternal();
6 | });
7 |
8 | ipcMain.handle("open-external:unset", (_, requestingURL: string, openingURL: string) => {
9 | return unsetAlwaysOpenExternal(requestingURL, openingURL);
10 | });
11 |
--------------------------------------------------------------------------------
/src/main/controllers/windows-controller/types/extension-popup.ts:
--------------------------------------------------------------------------------
1 | import { BaseWindow } from "@/controllers/windows-controller/types/base";
2 | import { BrowserWindow } from "electron";
3 |
4 | export class ExtensionPopupWindow extends BaseWindow {
5 | constructor(browserWindow: BrowserWindow) {
6 | // Uses the browserWindow that was already created by the extension handler
7 | super("extension-popup", browserWindow);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/main/controllers/posthog-controller/posthog-error-capture-sdk/README.md:
--------------------------------------------------------------------------------
1 | # PostHog Error Capture
2 |
3 | This is taken from a directory in [PostHog/posthog-js-lite](https://github.com/PostHog/posthog-js-lite/tree/6f67f8a3e9724479011173f7b0fc0c190806da2b/posthog-node/src/extensions/error-tracking) and forked.
4 |
5 | ## Modifications
6 |
7 | - Added a fallback distinct ID to use when no distinct ID is provided.
8 | - Use fallback distinct ID for autocapture.
9 |
--------------------------------------------------------------------------------
/src/renderer/src/routes/onboarding/page.tsx:
--------------------------------------------------------------------------------
1 | import { OnboardingMain } from "@/components/onboarding/main";
2 | import { SettingsProvider } from "@/components/providers/settings-provider";
3 |
4 | function Page() {
5 | return (
6 |
6 |
13 | );
14 | }
15 |
--------------------------------------------------------------------------------
/src/renderer/src/routes/extensions/config.tsx:
--------------------------------------------------------------------------------
1 | import { ThemeProvider } from "@/components/main/theme";
2 | import { NuqsProvider } from "@/components/providers/nuqs-provider";
3 | import { RouteConfigType } from "@/types/routes";
4 | import { ReactNode } from "react";
5 |
6 | export const RouteConfig: RouteConfigType = {
7 | Providers: ({ children }: { children: ReactNode }) => {
8 | return (
9 |
7 |
10 |
11 | General
8 |{"Manage your browser's general settings"}
9 |Space Icon
19 |
21 |
35 |
36 | );
37 | }
38 |
--------------------------------------------------------------------------------
/src/renderer/src/components/ui/switch.tsx:
--------------------------------------------------------------------------------
1 | "use client";
2 |
3 | import * as React from "react";
4 | import { Switch as SwitchPrimitive } from "radix-ui";
5 |
6 | import { cn } from "@/lib/utils";
7 |
8 | function Switch({ className, ...props }: React.ComponentProps
6 | {/* Set document title */}
7 | Onboarding | Flow Browser
8 |
9 | {/* Static gradient orbs */}
10 |
14 |
15 |
19 |
20 | {/* Container for the actual screen content */}
21 |
26 | );
27 | }
28 |
29 | // Optional: export default if this is the primary export of the file
30 | export default OnboardingScreen;
31 |
--------------------------------------------------------------------------------
/src/main/ipc/app/updates.ts:
--------------------------------------------------------------------------------
1 | import { autoUpdateController } from "@/controllers/auto-update-controller";
2 | import { sendMessageToListeners } from "@/ipc/listeners-manager";
3 | import { ipcMain } from "electron";
4 | import { UpdateStatus } from "~/types/updates";
5 |
6 | ipcMain.handle("updates:is-auto-update-supported", () => {
7 | return autoUpdateController.isAutoUpdateSupported(process.platform);
8 | });
9 |
10 | ipcMain.handle("updates:get-update-status", () => {
11 | return autoUpdateController.getUpdateStatus();
12 | });
13 |
14 | ipcMain.handle("updates:check-for-updates", async () => {
15 | try {
16 | const result = await autoUpdateController.checkForUpdates();
17 | if (result?.isUpdateAvailable) {
18 | return true;
19 | }
20 | return false;
21 | } catch {
22 | return false;
23 | }
24 | });
25 |
26 | ipcMain.handle("updates:download-update", () => {
27 | return autoUpdateController.downloadUpdate();
28 | });
29 |
30 | ipcMain.handle("updates:install-update", () => {
31 | return autoUpdateController.installUpdate();
32 | });
33 |
34 | export function fireUpdateStatusChanged(updateStatus: UpdateStatus) {
35 | sendMessageToListeners("updates:on-update-status-changed", updateStatus);
36 | }
37 | autoUpdateController.on("status-changed", () => {
38 | fireUpdateStatusChanged(autoUpdateController.getUpdateStatus());
39 | });
40 |
--------------------------------------------------------------------------------
/src/main/ipc/session/profiles.ts:
--------------------------------------------------------------------------------
1 | import { profilesController, ProfileData } from "@/controllers/profiles-controller";
2 | import { ipcMain } from "electron";
3 | import { spacesController } from "@/controllers/spaces-controller";
4 | import { browserWindowsController } from "@/controllers/windows-controller/interfaces/browser";
5 |
6 | ipcMain.handle("profiles:get-all", async () => {
7 | return await profilesController.getAll();
8 | });
9 |
10 | ipcMain.handle("profiles:create", async (_event, profileName: string) => {
11 | return await profilesController.create(profileName);
12 | });
13 |
14 | ipcMain.handle("profiles:update", async (_event, profileId: string, profileData: Partial
22 | {/* Render children passed to the component */}
23 | {children}
24 |
25 |
15 |
32 | );
33 | }
34 |
--------------------------------------------------------------------------------
/src/main/controllers/app-menu-controller/menu/items/archive.ts:
--------------------------------------------------------------------------------
1 | import { MenuItemConstructorOptions } from "electron";
2 | import { getTabWcFromFocusedWindow } from "../helpers";
3 | import { getCurrentShortcut } from "@/modules/shortcuts";
4 |
5 | export const createArchiveMenu = (): MenuItemConstructorOptions => ({
6 | label: "Archive", // Consider renaming to "History" or "Navigation" if more appropriate
7 | submenu: [
8 | {
9 | label: "Go Back",
10 | accelerator: getCurrentShortcut("navigation.goBack"),
11 | click: () => {
12 | const tabWc = getTabWcFromFocusedWindow();
13 | if (!tabWc) return;
14 |
15 | const navigationHistory = tabWc.navigationHistory;
16 | // Check if back navigation is possible before calling goBack
17 | if (navigationHistory.canGoBack()) {
18 | navigationHistory.goBack();
19 | }
20 | }
21 | },
22 | {
23 | label: "Go Forward",
24 | accelerator: getCurrentShortcut("navigation.goForward"),
25 | click: () => {
26 | const tabWc = getTabWcFromFocusedWindow();
27 | if (!tabWc) return;
28 |
29 | const navigationHistory = tabWc.navigationHistory;
30 | // Check if forward navigation is possible before calling goForward
31 | if (navigationHistory.canGoForward()) {
32 | navigationHistory.goForward();
33 | }
34 | }
35 | }
36 | ]
37 | });
38 |
--------------------------------------------------------------------------------
/src/main/app/platform.ts:
--------------------------------------------------------------------------------
1 | import { app, Menu, MenuItem } from "electron";
2 | import { debugPrint } from "@/modules/output";
3 | import { browserWindowsController } from "@/controllers/windows-controller/interfaces/browser";
4 |
5 | function setupWindowsUserTasks() {
6 | app.setUserTasks([
7 | {
8 | program: process.execPath,
9 | arguments: "--new-window",
10 | iconPath: process.execPath,
11 | iconIndex: 0,
12 | title: "New Window",
13 | description: "Create a new window"
14 | }
15 | ]);
16 | }
17 |
18 | function setupMacOSDock() {
19 | const dockMenu = new Menu();
20 |
21 | dockMenu.append(
22 | new MenuItem({
23 | label: "New Window",
24 | click: () => {
25 | browserWindowsController.create();
26 | }
27 | })
28 | );
29 |
30 | dockMenu.append(
31 | new MenuItem({
32 | label: "New Incognito Window",
33 | enabled: false
34 | })
35 | );
36 |
37 | app.whenReady().then(() => {
38 | if ("dock" in app) {
39 | app.dock?.setMenu(dockMenu);
40 | }
41 | });
42 | }
43 |
44 | export function setupPlatformIntegration() {
45 | if (process.platform === "win32") {
46 | setupWindowsUserTasks();
47 | debugPrint("INITIALIZATION", "setup windows user tasks finished");
48 | } else if (process.platform === "darwin") {
49 | setupMacOSDock();
50 | debugPrint("INITIALIZATION", "setup macOS dock finished");
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/controllers/sessions-controller/intercept-rules/cors-bypass-custom-protocols.ts:
--------------------------------------------------------------------------------
1 | import { createBetterWebRequest } from "@/controllers/sessions-controller/web-requests";
2 | import type { Session } from "electron";
3 |
4 | /**
5 | * Setup CORS bypass for whitelisted protocols
6 | * @param session
7 | */
8 | export function setupCorsBypassForCustomProtocols(session: Session) {
9 | const webRequest = createBetterWebRequest(session.webRequest, "bypass-cors");
10 |
11 | const WHITELISTED_PROTOCOLS = ["flow:", "flow-internal:"];
12 |
13 | webRequest.onHeadersReceived((details, callback) => {
14 | const currentUrl = details.webContents?.getURL();
15 | const protocol = URL.parse(currentUrl ?? "")?.protocol;
16 |
17 | if (protocol && WHITELISTED_PROTOCOLS.includes(protocol)) {
18 | const newResponseHeaders = { ...details.responseHeaders };
19 |
20 | // Remove all Access-Control-Allow-Origin headers in different cases
21 | for (const header of Object.keys(newResponseHeaders)) {
22 | if (header.toLowerCase() == "access-control-allow-origin") {
23 | newResponseHeaders[header] = [];
24 | }
25 | }
26 |
27 | // Add the Access-Control-Allow-Origin header back with a wildcard
28 | newResponseHeaders["Access-Control-Allow-Origin"] = ["*"];
29 |
30 | callback({ responseHeaders: newResponseHeaders });
31 | return;
32 | }
33 |
34 | callback({});
35 | });
36 | }
37 |
--------------------------------------------------------------------------------
/src/renderer/src/components/settings/sections/shortcuts/components/reset-dialog.tsx:
--------------------------------------------------------------------------------
1 | import {
2 | Dialog,
3 | DialogContent,
4 | DialogDescription,
5 | DialogFooter,
6 | DialogHeader,
7 | DialogTitle
8 | } from "@/components/ui/dialog";
9 | import { Button } from "@/components/ui/button";
10 |
11 | interface ResetDialogProps {
12 | isOpen: boolean;
13 | onOpenChange: (open: boolean) => void;
14 | onConfirm: () => void;
15 | }
16 |
17 | export function ResetDialog({ isOpen, onOpenChange, onConfirm }: ResetDialogProps) {
18 | return (
19 |
43 | );
44 | }
45 |
--------------------------------------------------------------------------------
/src/shared/flow/interfaces/app/updates.ts:
--------------------------------------------------------------------------------
1 | import type { IPCListener } from "~/flow/types";
2 | import type { UpdateStatus } from "~/types/updates";
3 |
4 | // API //
5 | export interface FlowUpdatesAPI {
6 | /**
7 | * Checks if automatic updates are supported on the current platform
8 | * @returns Promise resolving to a boolean indicating support status
9 | */
10 | isAutoUpdateSupported: () => Promise
16 |
25 |
26 |
30 |
31 |
31 |
33 |
34 |
37 | {space.name}
35 |ID: {space.id}
36 |
36 |
42 | );
43 | };
44 |
45 | export default Attachments;
46 |
--------------------------------------------------------------------------------
/src/main/controllers/app-menu-controller/menu/helpers.ts:
--------------------------------------------------------------------------------
1 | import { tabsController } from "@/controllers/tabs-controller";
2 | import { browserWindowsManager, windowsController } from "@/controllers/windows-controller";
3 | import { BaseWindow } from "@/controllers/windows-controller/types";
4 | import { WebContents } from "electron";
5 |
6 | export const getFocusedWindow = () => {
7 | return windowsController.getFocused();
8 | };
9 |
10 | export const getFocusedBrowserWindow = () => {
11 | const window = getFocusedWindow();
12 |
13 | if (!window) return null;
14 | if (!browserWindowsManager.isInstanceOf(window)) {
15 | return null;
16 | }
17 |
18 | return window;
19 | };
20 |
21 | export const getTab = (window?: BaseWindow) => {
22 | if (!window) return null;
23 | if (!browserWindowsManager.isInstanceOf(window)) {
24 | return null;
25 | }
26 |
27 | const windowId = window.id;
28 |
29 | const spaceId = window.currentSpaceId;
30 | if (!spaceId) return null;
31 |
32 | const tab = tabsController.getFocusedTab(windowId, spaceId);
33 | if (!tab) return null;
34 | return tab;
35 | };
36 |
37 | export const getTabFromFocusedWindow = () => {
38 | const winData = getFocusedWindow();
39 | if (!winData) return null;
40 | return getTab(winData);
41 | };
42 |
43 | export const getTabWc = (window: BaseWindow): WebContents | null => {
44 | const tab = getTab(window);
45 | if (!tab) return null;
46 | return tab.webContents;
47 | };
48 |
49 | export const getTabWcFromFocusedWindow = (): WebContents | null => {
50 | const window = getFocusedWindow();
51 | if (!window) return null;
52 | return getTabWc(window);
53 | };
54 |
--------------------------------------------------------------------------------
/src/main/controllers/default-browser-controller/index.ts:
--------------------------------------------------------------------------------
1 | import { app } from "electron";
2 | import { registerAppForCurrentUserOnWindows } from "./windows-handler";
3 | import { exec } from "child_process";
4 |
5 | class DefaultBrowserController {
6 | public isDefaultBrowser(): boolean {
7 | if (process.platform === "win32") {
8 | return false;
9 | }
10 |
11 | const httpIsDefault = app.isDefaultProtocolClient("http");
12 | const httpsIsDefault = app.isDefaultProtocolClient("https");
13 |
14 | return httpIsDefault && httpsIsDefault;
15 | }
16 |
17 | public setDefaultBrowser(): Promise
37 | {Array.from(attachments.entries()).map(([key, { filename, content }]) => (
38 |
41 |
8 |
19 |
20 | Troubleshooting
21 | Tools to help resolve issues
22 |
23 |
24 |
27 |
30 |
33 |
36 |
37 |
38 |
39 | )}
40 |
41 | );
42 | }
43 |
--------------------------------------------------------------------------------
/src/main/ipc/README.md:
--------------------------------------------------------------------------------
1 | # IPC Namespaces
2 |
3 | This directory contains all `ipcMain` registrations that the Flow browser exposes to renderer processes. Each module keeps the handlers for a single area of the app (e.g. sessions, windows, browser state) and is imported by `src/main/ipc/main.ts`. Importing a module is enough to register its listeners.
4 |
5 | > **Renderer opt-in:** Renderers that expect push-style updates must emit `listeners:add`/`listeners:remove` (see below) so the main process can deliver broadcasts only to windows that are listening.
6 |
7 | ## Bootstrapping
8 |
9 | - `main.ts` — central entry point that imports every namespace. Add new IPC files here to ensure handlers run.
10 |
11 | ## Listener management
12 |
13 | - `listeners-manager.ts`
14 | - Tracks which `WebContents` listens to which channel via the `listeners:add` / `listeners:remove` events. Renderer messages should pass a unique listener id so they can unsubscribe cleanly.
15 | - Exposes helpers:
16 | - `sendMessageToListeners(channel, ...args)` — broadcast to every subscribed renderer.
17 | - `sendMessageToListenersWithWebContents(webContents[], channel, ...args)` — scoped broadcast.
18 |
19 | ## Adding a new namespace
20 |
21 | 1. Create a new file (or folder) under `src/main/ipc/` and register handlers with `ipcMain.on` / `ipcMain.handle`.
22 | 2. Add any broadcast helpers that other main-process modules can call instead of importing `ipcMain` directly.
23 | 3. If renderers should receive push updates, leverage `listeners-manager` and document the channel name. Remember to clean up listeners when renderer views unmount.
24 | 4. Import the new module from `src/main/ipc/main.ts`.
25 |
--------------------------------------------------------------------------------
/src/renderer/public/chrome-dino-game/scripts/neterror.slim.js:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Chromium Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style license that can be
3 | // found in the LICENSE file.
4 |
5 | const HIDDEN_CLASS = 'hidden';
6 |
7 | // Subframes use a different layout but the same html file. This is to make it
8 | // easier to support platforms that load the error page via different
9 | // mechanisms (Currently just iOS). We also use the subframe style for portals
10 | // as they are embedded like subframes and can't be interacted with by the user.
11 | let isSubFrame = false;
12 | if (window.top.location !== window.location || window.portalHost) {
13 | document.documentElement.setAttribute('subframe', '');
14 | isSubFrame = true;
15 | }
16 |
17 | // Adds an icon class to the list and removes classes previously set.
18 | function updateIconClass(newClass) {
19 | const frameSelector = isSubFrame ? '#sub-frame-error' : '#main-frame-error';
20 | const iconEl = document.querySelector(frameSelector + ' .icon');
21 |
22 | if (iconEl.classList.contains(newClass)) {
23 | return;
24 | }
25 |
26 | iconEl.className = 'icon ' + newClass;
27 | }
28 |
29 |
30 | function onDocumentLoad() {
31 | const iconClass = loadTimeData.valueExists('iconClass') &&
32 | loadTimeData.getValue('iconClass');
33 | updateIconClass(iconClass);
34 | if (!isSubFrame && iconClass === 'icon-offline') {
35 | document.documentElement.classList.add('offline');
36 | new Runner('.interstitial-wrapper');
37 | }
38 | }
39 | document.addEventListener('DOMContentLoaded', onDocumentLoad);
--------------------------------------------------------------------------------
/src/main/modules/logs.ts:
--------------------------------------------------------------------------------
1 | import { app } from "electron";
2 | import fs from "fs";
3 | import path from "path";
4 | import os from "os";
5 | import { FLOW_DATA_DIR } from "@/modules/paths";
6 |
7 | function getAppLogPath() {
8 | const appName = app.getName();
9 |
10 | if (process.platform === "darwin") {
11 | return path.join(os.homedir(), "Library/Logs", appName);
12 | }
13 |
14 | return path.join(FLOW_DATA_DIR, "logs");
15 | }
16 |
17 | const appLogPath = getAppLogPath();
18 |
19 | if (!fs.existsSync(appLogPath)) {
20 | fs.mkdirSync(appLogPath, { recursive: true });
21 | }
22 |
23 | // Get app version and format startup time for the log filename
24 | const appVersion = app.getVersion();
25 | const startupTime = new Date().toISOString().replace(/[:.]/g, "").slice(0, -1); // Format: YYYYMMDDTHHMMSSZ
26 | const logFileName = `${appVersion}_${startupTime}.log`;
27 |
28 | const logStream = fs.createWriteStream(path.join(appLogPath, logFileName), { flags: "a" });
29 | const originalStdoutWrite = process.stdout.write;
30 |
31 | type Callback = (err?: Error) => void;
32 |
33 | function newStdoutWrite(
34 | chunk: Uint8Array | string,
35 | encodingOrCallback?: BufferEncoding | Callback,
36 | callback?: Callback
37 | ) {
38 | let decoloredChunk = chunk;
39 | if (typeof chunk === "string") {
40 | // remove ANSI escape codes
41 | // eslint-disable-next-line no-control-regex
42 | decoloredChunk = chunk.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
43 | }
44 |
45 | logStream.write(decoloredChunk);
46 |
47 | // @ts-expect-error: This is a workaround to log to the log file
48 | return originalStdoutWrite.call(process.stdout, chunk, encodingOrCallback, callback);
49 | }
50 | process.stdout.write = newStdoutWrite;
51 |
--------------------------------------------------------------------------------
/src/main/controllers/sessions-controller/protocols/_protocols/flow/assets.ts:
--------------------------------------------------------------------------------
1 | import { PATHS } from "@/modules/paths";
2 | import { bufferToArrayBuffer, getContentType } from "@/modules/utils";
3 | import path from "path";
4 | import fsPromises from "fs/promises";
5 | import { HonoApp } from ".";
6 |
7 | export function registerAssetsRoutes(app: HonoApp) {
8 | app.get("/asset/*", async (c) => {
9 | // Extract the path after /asset
10 | let assetPath = c.req.path.replace(/^\/asset/, "");
11 | if (!assetPath || assetPath === "/") {
12 | return c.text("Asset path required", 400);
13 | }
14 |
15 | // Remove leading slash if present
16 | if (assetPath.startsWith("/")) {
17 | assetPath = assetPath.slice(1);
18 | }
19 |
20 | // Normalize the path to prevent directory traversal attacks
21 | const normalizedPath = path.normalize(assetPath).replace(/^(\.\.(\/|\\|$))+/, "");
22 |
23 | const filePath = path.join(PATHS.ASSETS, "public", normalizedPath);
24 |
25 | // Ensure the requested path is within the allowed directory
26 | const assetsDir = path.normalize(path.join(PATHS.ASSETS, "public"));
27 | if (!path.normalize(filePath).startsWith(assetsDir)) {
28 | return c.text("Access denied", 403);
29 | }
30 |
31 | try {
32 | // Read file contents
33 | const buffer = await fsPromises.readFile(filePath);
34 |
35 | // Determine content type based on file extension
36 | const contentType = getContentType(filePath);
37 | return c.body(bufferToArrayBuffer(buffer), 200, { "Content-Type": contentType });
38 | } catch (error) {
39 | console.error("Error serving asset:", error);
40 | return c.text("Asset not found", 404);
41 | }
42 | });
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/controllers/sessions-controller/protocols/_protocols/flow/extension-icon.ts:
--------------------------------------------------------------------------------
1 | import { getExtensionIcon } from "@/modules/extensions/management";
2 | import { loadedProfilesController } from "@/controllers/loaded-profiles-controller";
3 | import { HonoApp } from ".";
4 | import { bufferToArrayBuffer } from "@/modules/utils";
5 |
6 | export function registerExtensionIconRoutes(app: HonoApp) {
7 | app.get("/extension-icon", async (c) => {
8 | try {
9 | const extensionId = c.req.query("id");
10 | const profileId = c.req.query("profile");
11 |
12 | if (!extensionId || !profileId) {
13 | return c.text("Missing arguments", 400);
14 | }
15 |
16 | const loadedProfile = loadedProfilesController.get(profileId);
17 | if (!loadedProfile) {
18 | return c.text("No loaded profile found", 404);
19 | }
20 |
21 | const { extensionsManager } = loadedProfile;
22 |
23 | const extData = extensionsManager.getExtensionDataFromCache(extensionId);
24 | if (!extData) {
25 | return c.text("No extension data found", 404);
26 | }
27 |
28 | const extensionPath = await extensionsManager.getExtensionPath(extensionId, extData);
29 | if (!extensionPath) {
30 | return c.text("No extension path found", 404);
31 | }
32 |
33 | const icon = await getExtensionIcon(extensionPath);
34 | if (!icon) {
35 | return c.text("Extension icon not found", 404);
36 | }
37 |
38 | return c.body(bufferToArrayBuffer(icon.toPNG()), 200, { "Content-Type": "image/png" });
39 | } catch (error) {
40 | console.error("Error retrieving extension icon:", error);
41 | return c.text("Internal server error", 500);
42 | }
43 | });
44 | }
45 |
--------------------------------------------------------------------------------
/src/renderer/src/lib/omnibox/data-providers/history.ts:
--------------------------------------------------------------------------------
1 | interface HistoryEntry {
2 | id: number;
3 | url: string;
4 | title: string;
5 | visitCount: number;
6 | typedCount: number; // How often typed directly
7 | lastVisitTime: number; // Timestamp
8 | }
9 |
10 | const MOCK_HISTORY_ENABLED = false;
11 |
12 | const MOCK_HISTORY: HistoryEntry[] = [
13 | {
14 | id: 1,
15 | url: "https://www.google.com/",
16 | title: "Google",
17 | visitCount: 100,
18 | typedCount: 20,
19 | lastVisitTime: Date.now() - 86400000 * 1
20 | },
21 | {
22 | id: 2,
23 | url: "https://github.com/",
24 | title: "GitHub",
25 | visitCount: 50,
26 | typedCount: 10,
27 | lastVisitTime: Date.now() - 86400000 * 2
28 | },
29 | {
30 | id: 3,
31 | url: "https://stackoverflow.com/questions",
32 | title: "Stack Overflow - Questions",
33 | visitCount: 80,
34 | typedCount: 5,
35 | lastVisitTime: Date.now() - 3600000 * 5
36 | },
37 | {
38 | id: 4,
39 | url: "https://developer.mozilla.org/en-US/",
40 | title: "MDN Web Docs",
41 | visitCount: 30,
42 | typedCount: 2,
43 | lastVisitTime: Date.now() - 86400000 * 7
44 | },
45 | {
46 | id: 5,
47 | url: "http://localhost:3000/",
48 | title: "Local Dev Server",
49 | visitCount: 200,
50 | typedCount: 50,
51 | lastVisitTime: Date.now() - 3600000 * 1
52 | },
53 | {
54 | id: 6,
55 | url: "https://news.ycombinator.com/",
56 | title: "Hacker News",
57 | visitCount: 60,
58 | typedCount: 8,
59 | lastVisitTime: Date.now() - 86400000 * 3
60 | }
61 | ];
62 |
63 | export async function getHistory() {
64 | if (MOCK_HISTORY_ENABLED) {
65 | return MOCK_HISTORY;
66 | }
67 | return [];
68 | }
69 |
--------------------------------------------------------------------------------
/src/shared/flow/interfaces/browser/navigation.ts:
--------------------------------------------------------------------------------
1 | export type NavigationEntry = {
2 | title: string;
3 | url: string;
4 | };
5 |
6 | export type TabNavigationStatus = {
7 | // Index 0: Represents the earliest visited page.
8 | // Index N: Represents the most recent page visited.
9 | navigationHistory: NavigationEntry[];
10 | activeIndex: number;
11 | canGoBack: boolean;
12 | canGoForward: boolean;
13 | };
14 |
15 | // API //
16 | export interface FlowNavigationAPI {
17 | /**
18 | * Gets the navigation status of a tab
19 | * This can only be called from the Browser UI
20 | * @param tabId The id of the tab to get the navigation status of
21 | */
22 | getTabNavigationStatus: (tabId: number) => Promise
9 |
12 |
13 | About
10 |Information about your browser
11 |
35 |
44 | {loadedPerc < 100 && (
45 |
49 | )}
50 |
51 | );
52 | }
53 |
--------------------------------------------------------------------------------
37 |
43 |
40 |
42 |