arn-browser 0.0.2 → 0.0.3

package/dist/webgl/db-compat.js

@@ -0,0 +1,44 @@
+// Database compatibility layer for Bun and Node.js
+// Bun has built-in SQLite support, while Node.js uses better-sqlite3
+// Check if we're running in Bun
+const isBun = typeof globalThis.Bun !== "undefined";
+export function openDatabase(dbPath) {
+    if (isBun) {
+        // Use Bun's built-in SQLite
+        // @ts-ignore - Bun's sqlite module
+        const { Database } = require("bun:sqlite");
+        const db = new Database(dbPath, { readonly: true });
+        return {
+            prepare(sql) {
+                const stmt = db.prepare(sql);
+                return {
+                    all(...params) {
+                        return stmt.all(...params);
+                    },
+                };
+            },
+            close() {
+                db.close();
+            },
+        };
+    }
+    else {
+        // Use better-sqlite3 for Node.js
+        // Dynamic import to avoid bundling issues
+        const Database = require("better-sqlite3");
+        const db = new Database(dbPath, { readonly: true });
+        return {
+            prepare(sql) {
+                const stmt = db.prepare(sql);
+                return {
+                    all(...params) {
+                        return stmt.all(...params);
+                    },
+                };
+            },
+            close() {
+                db.close();
+            },
+        };
+    }
+}

package/dist/webgl/sample.d.ts

@@ -0,0 +1,19 @@
+interface WebGLData {
+    vendor: string;
+    renderer: string;
+    data: string;
+    win: number;
+    mac: number;
+    lin: number;
+    webGl2Enabled: boolean;
+}
+export declare function sampleWebGL(os: "win" | "mac" | "lin", vendor?: string, renderer?: string): Promise<WebGLData>;
+interface VendorRenderer {
+    vendor: string;
+    renderer: string;
+}
+interface PossiblePairs {
+    [key: string]: Array<VendorRenderer>;
+}
+export declare function getPossiblePairs(): Promise<PossiblePairs>;
+export {};

package/dist/webgl/sample.js

@@ -0,0 +1,85 @@
+import path from "node:path";
+import { openDatabase } from "./db-compat.js";
+import { OS_ARCH_MATRIX } from "../pkgman.js";
+// Get database path relative to this file
+const DB_PATH = path.join(import.meta.dirname, "..", "data-files", "webgl_data.db");
+export async function sampleWebGL(os, vendor, renderer) {
+    if (!OS_ARCH_MATRIX[os]) {
+        throw new Error(`Invalid OS: ${os}. Must be one of: win, mac, lin`);
+    }
+    const db = openDatabase(DB_PATH);
+    let query = "";
+    let params = [];
+    if (vendor && renderer) {
+        query = `SELECT vendor, renderer, data, ${os} FROM webgl_fingerprints WHERE vendor = ? AND renderer = ?`;
+        params = [vendor, renderer];
+    }
+    else {
+        query = `SELECT vendor, renderer, data, ${os} FROM webgl_fingerprints WHERE ${os} > 0`;
+    }
+    return new Promise((resolve, reject) => {
+        try {
+            const rows = db.prepare(query).all(...params);
+            if (rows.length === 0) {
+                reject(new Error(`No WebGL data found for OS: ${os}`));
+                return;
+            }
+            if (vendor && renderer) {
+                const result = rows[0];
+                if (result[os] <= 0) {
+                    const pairs = db
+                        .prepare(`SELECT DISTINCT vendor, renderer FROM webgl_fingerprints WHERE ${os} > 0`)
+                        .all();
+                    reject(new Error(`Vendor "${vendor}" and renderer "${renderer}" combination not valid for ${os}. Possible pairs: ${pairs.map((pair) => `${pair.vendor}, ${pair.renderer}`).join(", ")}`));
+                    return;
+                }
+                resolve(JSON.parse(result.data));
+            }
+            else {
+                const dataStrs = rows.map((row) => row.data);
+                const probs = rows.map((row) => row[os]);
+                const probsArray = probs.map((p) => p / probs.reduce((a, b) => a + b, 0));
+                function weightedRandomChoice(weights) {
+                    const sum = weights.reduce((acc, weight) => acc + weight, 0);
+                    const threshold = Math.random() * sum;
+                    let cumulativeSum = 0;
+                    for (let i = 0; i < weights.length; i++) {
+                        cumulativeSum += weights[i];
+                        if (cumulativeSum >= threshold) {
+                            return i;
+                        }
+                    }
+                    return weights.length - 1; // Fallback in case of rounding errors
+                }
+                const idx = weightedRandomChoice(probsArray);
+                resolve(JSON.parse(dataStrs[idx]));
+            }
+        }
+        catch (err) {
+            reject(err);
+        }
+    }).finally(() => {
+        db.close();
+    });
+}
+export async function getPossiblePairs() {
+    const db = openDatabase(DB_PATH);
+    const result = {};
+    return new Promise((resolve, reject) => {
+        try {
+            const osTypes = Object.keys(OS_ARCH_MATRIX);
+            osTypes.forEach((os_type) => {
+                const rows = db
+                    .prepare(`SELECT DISTINCT vendor, renderer FROM webgl_fingerprints WHERE ${os_type} > 0 ORDER BY ${os_type} DESC`)
+                    .all();
+                result[os_type] = rows;
+            });
+            resolve(result);
+        }
+        catch (err) {
+            reject(err);
+        }
+    }).finally(() => {
+        db.close();
+    });
+}

package/package.json

@@ -1,10 +1,11 @@
 {
 	"name": "arn-browser",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"author": "",
 	"license": "MPL-2.0",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
+	"bin": "dist/__main__.js",
 	"scripts": {
 		"build": "rimraf dist && tsc && npm run copy-files",
 		"test": "vitest",