@rslint/core 0.5.2 → 0.5.4-canary.1781059600

package/dist/browser.js

@@ -1,7 +1,4 @@
-/**
- * Browser implementation of RslintService using web workers
- */
-export class BrowserRslintService {
+class BrowserRslintService {
     nextMessageId;
     pendingMessages;
     worker;
@@ -9,139 +6,110 @@ export class BrowserRslintService {
     chunks;
     chunkSize;
     expectedSize;
-    constructor(options) {
+    constructor(options){
         this.nextMessageId = 1;
         this.pendingMessages = new Map();
         this.chunks = [];
         this.chunkSize = 0;
         this.expectedSize = null;
-        // In browser, we need to use a web worker that can run the rslint binary
-        // This would typically be a WASM version or a worker that can spawn processes
         this.workerUrl = options.workerUrl;
         this.ensureWorker(options.wasmUrl);
     }
-    /**
-     * Initialize the web worker
-     */
     async ensureWorker(wasmUrl) {
         if (!this.worker) {
-            this.worker = new Worker(this.workerUrl, { name: 'rslint-worker.js' });
-            this.worker.onmessage = (event) => {
+            this.worker = new Worker(this.workerUrl, {
+                name: 'rslint-worker.js'
+            });
+            this.worker.onmessage = (event)=>{
                 this.handlePacket(event.data);
             };
-            this.worker.onerror = (error) => {
+            this.worker.onerror = (error)=>{
                 console.error('Worker error:', error);
-                // Reject all pending messages
-                for (const [, pending] of this.pendingMessages) {
-                    pending.reject(new Error(`Worker error: ${error.message}`));
-                }
+                for (const [, pending] of this.pendingMessages)pending.reject(new Error(`Worker error: ${error.message}`));
                 this.pendingMessages.clear();
             };
             this.worker.postMessage({
                 kind: 'init',
-                data: { version: '1.0.0', wasmURL: wasmUrl },
+                data: {
+                    version: '1.0.0',
+                    wasmURL: wasmUrl
+                }
             });
         }
         return this.worker;
     }
-    /**
-     * Handle incoming binary data chunks
-     */
     handlePacket(chunk) {
         this.chunks.push(chunk);
         this.chunkSize += chunk.length;
-        // Process complete messages
-        while (true) {
-            // Read message length if we don't have it yet
-            if (this.expectedSize === null) {
-                if (this.chunkSize < 4)
-                    return;
-                // Combine chunks to read the message length
+        while(true){
+            if (null === this.expectedSize) {
+                if (this.chunkSize < 4) return;
                 const combined = this.combineChunks();
                 const dataView = new DataView(combined.buffer, combined.byteOffset, combined.byteLength);
-                this.expectedSize = dataView.getUint32(0, true); // true for little-endian
-                // Remove length bytes from buffer
-                this.chunks = [combined.slice(4)];
+                this.expectedSize = dataView.getUint32(0, true);
+                this.chunks = [
+                    combined.slice(4)
+                ];
                 this.chunkSize -= 4;
             }
-            // Check if we have the full message
-            if (this.chunkSize < this.expectedSize)
-                return;
-            // Read the message content
+            if (this.chunkSize < this.expectedSize) return;
             const combined = this.combineChunks();
             const messageBytes = combined.slice(0, this.expectedSize);
             const message = new TextDecoder().decode(messageBytes);
-            // Handle the message
             try {
                 const parsed = JSON.parse(message);
                 this.handleResponse(parsed);
-            }
-            catch (err) {
+            } catch (err) {
                 console.error('Error parsing message:', err);
             }
-            // Reset for next message
-            this.chunks = [combined.slice(this.expectedSize)];
+            this.chunks = [
+                combined.slice(this.expectedSize)
+            ];
             this.chunkSize = this.chunks[0].length;
             this.expectedSize = null;
         }
     }
-    /**
-     * Combine multiple Uint8Array chunks into a single Uint8Array
-     */
     combineChunks() {
-        if (this.chunks.length === 1) {
-            return this.chunks[0];
-        }
-        const totalLength = this.chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        if (1 === this.chunks.length) return this.chunks[0];
+        const totalLength = this.chunks.reduce((sum, chunk)=>sum + chunk.length, 0);
         const combined = new Uint8Array(totalLength);
         let offset = 0;
-        for (const chunk of this.chunks) {
+        for (const chunk of this.chunks){
             combined.set(chunk, offset);
             offset += chunk.length;
         }
         return combined;
     }
-    /**
-     * Send a message to the worker
-     */
     async sendMessage(kind, data) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject)=>{
             const id = this.nextMessageId++;
-            const message = { id, kind, data };
-            // Register promise callbacks
-            this.pendingMessages.set(id, { resolve, reject });
-            // Send message to worker
+            const message = {
+                id,
+                kind,
+                data
+            };
+            this.pendingMessages.set(id, {
+                resolve,
+                reject
+            });
             this.worker.postMessage(message);
         });
     }
-    /**
-     * Handle messages from the worker
-     */
     handleResponse(message) {
         const { id, kind, data } = message;
         const pending = this.pendingMessages.get(id);
-        if (!pending)
-            return;
+        if (!pending) return;
         this.pendingMessages.delete(id);
-        if (kind === 'error') {
-            pending.reject(new Error(data.message));
-        }
-        else {
-            pending.resolve(data);
-        }
+        if ('error' === kind) pending.reject(new Error(data.message));
+        else pending.resolve(data);
     }
-    /**
-     * Terminate the worker
-     */
     terminate() {
         if (this.worker) {
-            // Reject all pending messages
-            for (const [, pending] of this.pendingMessages) {
-                pending.reject(new Error('Service terminated'));
-            }
+            for (const [, pending] of this.pendingMessages)pending.reject(new Error('Service terminated'));
             this.pendingMessages.clear();
             this.worker.terminate();
             this.worker = null;
         }
     }
 }
+export { BrowserRslintService };

package/dist/cli.d.ts

@@ -1,2 +1,3 @@
-export declare function run(binPath: string, argv: string[], startTime: number): Promise<number>;
-//# sourceMappingURL=cli.d.ts.map
+export declare function run(binPath: string, argv: string[], startTime: number): Promise<number>;
+
+export { }