recker 1.0.43 → 1.0.44

package/dist/browser/ai/vector/store.js

@@ -0,0 +1,82 @@
+import { cosineSimilarity } from './similarity.js';
+export class MemoryVectorStore {
+    documents = new Map();
+    client;
+    model;
+    constructor(options = {}) {
+        this.client = options.client;
+        this.model = options.model;
+    }
+    async add(docs) {
+        const docsToEmbed = [];
+        const readyDocs = [];
+        for (const doc of docs) {
+            const id = doc.id || Math.random().toString(36).substring(7);
+            const fullDoc = {
+                id,
+                content: doc.content,
+                metadata: doc.metadata || {},
+                embedding: doc.embedding,
+            };
+            if (!fullDoc.embedding) {
+                docsToEmbed.push(fullDoc);
+            }
+            else {
+                readyDocs.push(fullDoc);
+            }
+        }
+        if (docsToEmbed.length > 0) {
+            if (!this.client) {
+                throw new Error('AI Client required to generate embeddings. Pass "client" to constructor or provide "embedding" in document.');
+            }
+            const contents = docsToEmbed.map(d => d.content);
+            const response = await this.client.embed({
+                model: this.model,
+                input: contents,
+            });
+            docsToEmbed.forEach((doc, i) => {
+                doc.embedding = response.embeddings[i];
+                readyDocs.push(doc);
+            });
+        }
+        for (const doc of readyDocs) {
+            this.documents.set(doc.id, doc);
+        }
+    }
+    async search(query, limit = 3, threshold = 0.0) {
+        if (this.documents.size === 0)
+            return [];
+        if (!this.client) {
+            throw new Error('AI Client required to search by text query.');
+        }
+        const response = await this.client.embed({
+            model: this.model,
+            input: query,
+        });
+        const queryEmbedding = response.embeddings[0];
+        const results = [];
+        for (const doc of this.documents.values()) {
+            if (!doc.embedding)
+                continue;
+            const score = cosineSimilarity(queryEmbedding, doc.embedding);
+            if (score >= threshold) {
+                results.push({
+                    ...doc,
+                    score,
+                });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    delete(id) {
+        return this.documents.delete(id);
+    }
+    clear() {
+        this.documents.clear();
+    }
+    get count() {
+        return this.documents.size;
+    }
+}

package/dist/browser/browser/cache.d.ts

@@ -1,40 +1,2 @@
-export interface CacheEntry<T = unknown> {
-    key: string;
-    value: T;
-    createdAt: number;
-    expiresAt?: number;
-    etag?: string;
-    lastModified?: string;
-}
-export interface BrowserCacheOptions {
-    dbName?: string;
-    storeName?: string;
-    defaultTTL?: number;
-    maxEntries?: number;
-}
-export declare class IndexedDBStorage {
-    private dbName;
-    private storeName;
-    private defaultTTL;
-    private maxEntries;
-    private db;
-    private initPromise;
-    constructor(options?: BrowserCacheOptions);
-    init(): Promise<void>;
-    get<T = unknown>(key: string): Promise<CacheEntry<T> | null>;
-    set<T = unknown>(key: string, value: T, ttl?: number, metadata?: {
-        etag?: string;
-        lastModified?: string;
-    }): Promise<void>;
-    delete(key: string): Promise<boolean>;
-    has(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    keys(): Promise<string[]>;
-    size(): Promise<number>;
-    cleanup(): Promise<number>;
-    private enforceMaxEntries;
-    close(): void;
-    destroy(): Promise<void>;
-}
-export declare function isIndexedDBAvailable(): boolean;
-export declare function getBrowserCacheStorage(options?: BrowserCacheOptions): IndexedDBStorage | null;
+export { IndexedDBStorage } from '../cache/indexed-db.js';
+export { ServiceWorkerCache } from '../cache/service-worker-cache.js';

package/dist/browser/browser/cache.js

@@ -1,199 +1,2 @@
-export class IndexedDBStorage {
-    dbName;
-    storeName;
-    defaultTTL;
-    maxEntries;
-    db = null;
-    initPromise = null;
-    constructor(options = {}) {
-        this.dbName = options.dbName ?? 'recker-cache';
-        this.storeName = options.storeName ?? 'responses';
-        this.defaultTTL = options.defaultTTL ?? 5 * 60 * 1000;
-        this.maxEntries = options.maxEntries ?? 1000;
-    }
-    async init() {
-        if (this.db)
-            return;
-        if (this.initPromise)
-            return this.initPromise;
-        this.initPromise = new Promise((resolve, reject) => {
-            const request = indexedDB.open(this.dbName, 1);
-            request.onerror = () => {
-                reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
-            };
-            request.onsuccess = () => {
-                this.db = request.result;
-                resolve();
-            };
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(this.storeName)) {
-                    const store = db.createObjectStore(this.storeName, { keyPath: 'key' });
-                    store.createIndex('expiresAt', 'expiresAt', { unique: false });
-                }
-            };
-        });
-        return this.initPromise;
-    }
-    async get(key) {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.get(key);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => {
-                const entry = request.result;
-                if (!entry) {
-                    resolve(null);
-                    return;
-                }
-                if (entry.expiresAt && entry.expiresAt < Date.now()) {
-                    this.delete(key).catch(() => { });
-                    resolve(null);
-                    return;
-                }
-                resolve(entry);
-            };
-        });
-    }
-    async set(key, value, ttl, metadata) {
-        await this.init();
-        const entry = {
-            key,
-            value,
-            createdAt: Date.now(),
-            expiresAt: ttl !== undefined ? Date.now() + ttl : undefined,
-            etag: metadata?.etag,
-            lastModified: metadata?.lastModified,
-        };
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.put(entry);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve();
-            transaction.oncomplete = () => {
-                this.enforceMaxEntries().catch(() => { });
-            };
-        });
-    }
-    async delete(key) {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.delete(key);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve(true);
-        });
-    }
-    async has(key) {
-        const entry = await this.get(key);
-        return entry !== null;
-    }
-    async clear() {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.clear();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve();
-        });
-    }
-    async keys() {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.getAllKeys();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve(request.result);
-        });
-    }
-    async size() {
-        await this.init();
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.count();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve(request.result);
-        });
-    }
-    async cleanup() {
-        await this.init();
-        const now = Date.now();
-        let removed = 0;
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const index = store.index('expiresAt');
-            const range = IDBKeyRange.upperBound(now);
-            const request = index.openCursor(range);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
-                if (cursor) {
-                    cursor.delete();
-                    removed++;
-                    cursor.continue();
-                }
-            };
-            transaction.oncomplete = () => resolve(removed);
-        });
-    }
-    async enforceMaxEntries() {
-        const currentSize = await this.size();
-        if (currentSize <= this.maxEntries)
-            return;
-        const toRemove = currentSize - this.maxEntries;
-        return new Promise((resolve, reject) => {
-            const transaction = this.db.transaction(this.storeName, 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const index = store.index('expiresAt');
-            let removed = 0;
-            const request = index.openCursor();
-            request.onerror = () => reject(request.error);
-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
-                if (cursor && removed < toRemove) {
-                    cursor.delete();
-                    removed++;
-                    cursor.continue();
-                }
-            };
-            transaction.oncomplete = () => resolve();
-        });
-    }
-    close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-            this.initPromise = null;
-        }
-    }
-    async destroy() {
-        this.close();
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.deleteDatabase(this.dbName);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => resolve();
-        });
-    }
-}
-export function isIndexedDBAvailable() {
-    try {
-        return typeof indexedDB !== 'undefined' && indexedDB !== null;
-    }
-    catch {
-        return false;
-    }
-}
-export function getBrowserCacheStorage(options) {
-    if (isIndexedDBAvailable()) {
-        return new IndexedDBStorage(options);
-    }
-    return null;
-}
+export { IndexedDBStorage } from '../cache/indexed-db.js';
+export { ServiceWorkerCache } from '../cache/service-worker-cache.js';

package/dist/browser/browser/index.d.ts

@@ -4,6 +4,7 @@ export * from '../core/client.js';
 export * from '../core/request.js';
 export * from '../core/response.js';
 export * from '../transport/fetch.js';
+export * from '../transport/worker.js';
 export * from '../plugins/retry.js';
 export * from '../plugins/rate-limit.js';
 export * from '../plugins/dedup.js';
@@ -18,12 +19,19 @@ export * from '../plugins/jsonrpc.js';
 export * from '../plugins/grpc-web.js';
 export * from '../plugins/soap.js';
 export * from '../plugins/odata.js';
+export * from '../plugins/har-recorder.js';
+export * from '../plugins/network-simulation.js';
 export * from '../plugins/auth.js';
 export * from '../cache/memory-storage.js';
+export * from '../cache/indexed-db.js';
 export * from '../utils/body.js';
 export * from '../utils/header-parser.js';
 export * from '../utils/link-header.js';
+export * from '../utils/user-agent.js';
 export * from '../utils/charset.js';
+export * from '../seo/analyzer.js';
+export * as ai from '../ai/index.js';
+export * as presets from '../presets/index.js';
 export * from '../constants/http-status.js';
 export * from './crypto.js';
 export * from './cache.js';

package/dist/browser/browser/index.js

@@ -4,6 +4,7 @@ export * from '../core/client.js';
 export * from '../core/request.js';
 export * from '../core/response.js';
 export * from '../transport/fetch.js';
+export * from '../transport/worker.js';
 export * from '../plugins/retry.js';
 export * from '../plugins/rate-limit.js';
 export * from '../plugins/dedup.js';
@@ -18,12 +19,19 @@ export * from '../plugins/jsonrpc.js';
 export * from '../plugins/grpc-web.js';
 export * from '../plugins/soap.js';
 export * from '../plugins/odata.js';
+export * from '../plugins/har-recorder.js';
+export * from '../plugins/network-simulation.js';
 export * from '../plugins/auth.js';
 export * from '../cache/memory-storage.js';
+export * from '../cache/indexed-db.js';
 export * from '../utils/body.js';
 export * from '../utils/header-parser.js';
 export * from '../utils/link-header.js';
+export * from '../utils/user-agent.js';
 export * from '../utils/charset.js';
+export * from '../seo/analyzer.js';
+export * as ai from '../ai/index.js';
+export * as presets from '../presets/index.js';
 export * from '../constants/http-status.js';
 export * from './crypto.js';
 export * from './cache.js';

package/dist/browser/browser/recker.d.ts

@@ -1,6 +1,9 @@
 import { Client, type ExtendedClientOptions } from '../core/client.js';
 import { type RequestPromise } from '../core/request-promise.js';
 import type { RequestOptions } from '../types/index.js';
+import { analyzeSeo } from '../seo/analyzer.js';
+import { createAI } from '../ai/index.js';
+import { simulateNetwork } from '../plugins/network-simulation.js';
 export declare function get(url: string, options?: RequestOptions): RequestPromise;
 export declare function post(url: string, options?: RequestOptions): RequestPromise;
 export declare function put(url: string, options?: RequestOptions): RequestPromise;
@@ -18,9 +21,13 @@ export declare const recker: {
     head: typeof head;
     options: typeof options;
     ws: typeof ws;
+    seo: typeof analyzeSeo;
+    ai: typeof createAI;
+    har: import("../plugins/har-recorder.js").HarRecorder;
+    simulateNetwork: typeof simulateNetwork;
     client: (opts?: ExtendedClientOptions) => Client;
     reset: () => void;
     isBrowser: true;
-    unavailable: readonly ["whois", "whoisAvailable", "dns", "dnsSecurity", "dnsClient", "whoisClient", "ai", "aiClient"];
+    unavailable: readonly ["whois", "whoisAvailable", "dns", "dnsSecurity", "dnsClient", "whoisClient"];
 };
 export default recker;

package/dist/browser/browser/recker.js

@@ -1,5 +1,9 @@
 import { createClient } from '../core/client.js';
 import { FetchTransport } from '../transport/fetch.js';
+import { analyzeSeo } from '../seo/analyzer.js';
+import { createAI } from '../ai/index.js';
+import { harRecorder } from '../plugins/har-recorder.js';
+import { simulateNetwork } from '../plugins/network-simulation.js';
 let _defaultClient = null;
 function getDefaultClient() {
     if (!_defaultClient) {
@@ -42,6 +46,10 @@ export const recker = {
     head,
     options,
     ws,
+    seo: analyzeSeo,
+    ai: createAI,
+    har: harRecorder,
+    simulateNetwork,
     client: (opts) => createClient({ ...opts, transport: new FetchTransport() }),
     reset: () => {
         _defaultClient = null;
@@ -54,8 +62,6 @@ export const recker = {
         'dnsSecurity',
         'dnsClient',
         'whoisClient',
-        'ai',
-        'aiClient',
     ],
 };
 export default recker;

package/dist/browser/cache/indexed-db.d.ts

@@ -0,0 +1,10 @@
+import type { CacheStorage, CacheEntry } from '../types/index.js';
+export declare class IndexedDBStorage implements CacheStorage {
+    private dbPromise;
+    constructor(dbName?: string);
+    private openDB;
+    get(key: string): Promise<CacheEntry | undefined | null>;
+    set(key: string, value: CacheEntry, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/browser/cache/indexed-db.js

@@ -0,0 +1,88 @@
+const DB_NAME = 'recker-cache';
+const STORE_NAME = 'entries';
+const DB_VERSION = 1;
+export class IndexedDBStorage {
+    dbPromise;
+    constructor(dbName = DB_NAME) {
+        this.dbPromise = this.openDB(dbName);
+    }
+    openDB(dbName) {
+        return new Promise((resolve, reject) => {
+            if (typeof indexedDB === 'undefined') {
+                reject(new Error('IndexedDB is not supported in this environment'));
+                return;
+            }
+            const request = indexedDB.open(dbName, DB_VERSION);
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    db.createObjectStore(STORE_NAME, { keyPath: 'key' });
+                }
+            };
+            request.onsuccess = (event) => {
+                resolve(event.target.result);
+            };
+            request.onerror = (event) => {
+                reject(event.target.error);
+            };
+        });
+    }
+    async get(key) {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readonly');
+            const store = transaction.objectStore(STORE_NAME);
+            const request = store.get(key);
+            request.onsuccess = () => {
+                const result = request.result;
+                if (!result) {
+                    resolve(null);
+                    return;
+                }
+                if (result.expiresAt && Date.now() > result.expiresAt) {
+                    this.delete(key).catch(() => { });
+                    resolve(null);
+                    return;
+                }
+                resolve(result.value);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async set(key, value, ttl) {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readwrite');
+            const store = transaction.objectStore(STORE_NAME);
+            const expiresAt = Date.now() + ttl;
+            const item = {
+                key,
+                value,
+                expiresAt
+            };
+            const request = store.put(item);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async delete(key) {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readwrite');
+            const store = transaction.objectStore(STORE_NAME);
+            const request = store.delete(key);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async clear() {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readwrite');
+            const store = transaction.objectStore(STORE_NAME);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+}

package/dist/browser/cache/service-worker-cache.d.ts

@@ -0,0 +1,18 @@
+import type { CacheStorage, CacheEntry } from '../types/index.js';
+export declare class ServiceWorkerCache implements CacheStorage {
+    private cacheName;
+    private cachePromise;
+    constructor(options?: {
+        cacheName?: string;
+    });
+    static isSupported(): boolean;
+    private getCache;
+    private keyToUrl;
+    get(key: string): Promise<CacheEntry | undefined | null>;
+    set(key: string, value: CacheEntry, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    size(): Promise<number>;
+    prune(): Promise<number>;
+}

package/dist/browser/cache/service-worker-cache.js

@@ -0,0 +1,103 @@
+const CACHE_NAME = 'recker-cache-v1';
+export class ServiceWorkerCache {
+    cacheName;
+    cachePromise = null;
+    constructor(options = {}) {
+        this.cacheName = options.cacheName || CACHE_NAME;
+    }
+    static isSupported() {
+        return typeof caches !== 'undefined';
+    }
+    async getCache() {
+        if (!this.cachePromise) {
+            if (!ServiceWorkerCache.isSupported()) {
+                throw new Error('Cache API is not supported in this environment');
+            }
+            this.cachePromise = caches.open(this.cacheName);
+        }
+        return this.cachePromise;
+    }
+    keyToUrl(key) {
+        return `https://recker-cache.local/${encodeURIComponent(key)}`;
+    }
+    async get(key) {
+        try {
+            const cache = await this.getCache();
+            const url = this.keyToUrl(key);
+            const response = await cache.match(url);
+            if (!response) {
+                return null;
+            }
+            const data = await response.json();
+            if (data.expiresAt && Date.now() > data.expiresAt) {
+                this.delete(key).catch(() => { });
+                return null;
+            }
+            return data.entry;
+        }
+        catch {
+            return null;
+        }
+    }
+    async set(key, value, ttl) {
+        const cache = await this.getCache();
+        const url = this.keyToUrl(key);
+        const item = {
+            entry: value,
+            expiresAt: Date.now() + ttl,
+        };
+        const response = new Response(JSON.stringify(item), {
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Recker-Cache': 'true',
+                'X-Recker-Expires': String(item.expiresAt),
+            },
+        });
+        await cache.put(url, response);
+    }
+    async delete(key) {
+        const cache = await this.getCache();
+        const url = this.keyToUrl(key);
+        await cache.delete(url);
+    }
+    async clear() {
+        await caches.delete(this.cacheName);
+        this.cachePromise = null;
+    }
+    async keys() {
+        const cache = await this.getCache();
+        const requests = await cache.keys();
+        return requests
+            .map((req) => {
+            const url = new URL(req.url);
+            return decodeURIComponent(url.pathname.slice(1));
+        })
+            .filter((key) => key.length > 0);
+    }
+    async size() {
+        const keys = await this.keys();
+        return keys.length;
+    }
+    async prune() {
+        const cache = await this.getCache();
+        const requests = await cache.keys();
+        let removed = 0;
+        for (const request of requests) {
+            const response = await cache.match(request);
+            if (response) {
+                try {
+                    const data = await response.json();
+                    if (data.expiresAt && Date.now() > data.expiresAt) {
+                        await cache.delete(request);
+                        removed++;
+                    }
+                }
+                catch {
+                    await cache.delete(request);
+                    removed++;
+                }
+            }
+        }
+        return removed;
+    }
+}