fix(core): update

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '3.0.9',
+  version: '3.0.10',
   description: 'easy serving of static files'
 }

ts/interfaces/responsemodifier.ts

@@ -1,11 +1,11 @@
 export type TResponseModifier = <T>(responseArg: {
   headers: { [header: string]: number | string | string[] | undefined };
   path: string;
-  responseContent: string;
+  responseContent: Buffer;
   travelData?: T;
 }) => Promise<{
   headers: { [header: string]: number | string | string[] | undefined };
   path: string;
-  responseContent: string;
+  responseContent: Buffer;
   travelData?: T;
 }>;

ts/servertools/classes.compressor.ts

@@ -0,0 +1,76 @@
+import * as plugins from '../typedserver.plugins.js';
+
+export class Compressor {
+  public async compressContent(
+    content: Buffer,
+    method: 'gzip' | 'deflate' | 'br' | 'none'
+  ): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      switch (method) {
+        case 'gzip':
+          plugins.zlib.gzip(content, (err, result) => {
+            if (err) reject(err);
+            else resolve(result);
+          });
+          break;
+        case 'br':
+          plugins.zlib.brotliCompress(content, (err, result) => {
+            if (err) reject(err);
+            else resolve(result);
+          });
+          break;
+        case 'deflate':
+          plugins.zlib.deflate(content, (err, result) => {
+            if (err) reject(err);
+            else resolve(result);
+          });
+          break;
+        default:
+          resolve(content);
+      }
+    });
+  }
+
+  public determineCompression(acceptEncoding: string | string[]) {
+    // Ensure acceptEncoding is a single string
+    const encodingString = Array.isArray(acceptEncoding)
+      ? acceptEncoding.join(', ')
+      : acceptEncoding;
+
+    let compressionMethod: 'gzip' | 'deflate' | 'br' | 'none' = 'none';
+
+    // Check and prioritize compression methods
+    if (/\bbr\b/.test(encodingString)) {
+      compressionMethod = 'br';
+    } else if (/\bgzip\b/.test(encodingString)) {
+      compressionMethod = 'gzip';
+    } else if (/\bdeflate\b/.test(encodingString)) {
+      compressionMethod = 'deflate';
+    }
+
+    return compressionMethod;
+  }
+
+  public async maybeCompress(requestHeaders: plugins.http.IncomingHttpHeaders, content: Buffer) {
+    const acceptEncoding = requestHeaders['accept-encoding'];
+    const compressionMethod = this.determineCompression(acceptEncoding);
+    const result = await this.compressContent(content, compressionMethod);
+    return {
+      result,
+      compressionMethod,
+    };
+  }
+
+  public createCompressionStream(method: 'gzip' | 'deflate' | 'br' | 'none') {
+    switch (method) {
+      case 'gzip':
+        return plugins.zlib.createGzip();
+      case 'br':
+        return plugins.zlib.createBrotliCompress();
+      case 'deflate':
+        return plugins.zlib.createDeflate();
+      default:
+        throw new Error('Invalid compression method');
+    }
+  }
+}

ts/servertools/classes.handlerproxy.ts

@@ -40,7 +40,7 @@ export class HandlerProxy extends Handler {
         }
       }
 
-      let responseToSend: string = proxiedResponse.body;
+      let responseToSend: Buffer = proxiedResponse.body;
       if (typeof responseToSend !== 'string') {
         console.log(proxyRequestUrl);
         console.log(responseToSend);

ts/servertools/classes.handlerstatic.ts

@@ -2,8 +2,10 @@ import * as plugins from '../typedserver.plugins.js';
 import * as interfaces from '../interfaces/index.js';
 
 import { Handler } from './classes.handler.js';
+import { Compressor } from './classes.compressor.js';
 
 export class HandlerStatic extends Handler {
+  public compressor = new Compressor();
   constructor(
     pathArg: string,
     optionsArg?: {
@@ -62,11 +64,9 @@ export class HandlerStatic extends Handler {
       }
 
       // lets actually care about serving, if security checks pass
-      let fileString: string;
-      let fileEncoding: 'binary' | 'utf8';
+      let fileBuffer: Buffer;
       try {
-        fileString = plugins.smartfile.fs.toStringSync(joinedPath);
-        fileEncoding = plugins.smartmime.getEncoding(joinedPath);
+        fileBuffer = plugins.smartfile.fs.toBufferSync(joinedPath);
         usedPath = joinedPath;
       } catch (err) {
         // try serving index.html instead
@@ -75,8 +75,7 @@ export class HandlerStatic extends Handler {
           console.log(`serving default path ${defaultPath} instead of ${joinedPath}`);
           try {
             parsedPath = plugins.path.parse(defaultPath);
-            fileString = plugins.smartfile.fs.toStringSync(defaultPath);
-            fileEncoding = plugins.smartmime.getEncoding(defaultPath);
+            fileBuffer = plugins.smartfile.fs.toBufferSync(defaultPath);
             usedPath = defaultPath;
           } catch (err) {
             res.writeHead(500);
@@ -99,7 +98,7 @@ export class HandlerStatic extends Handler {
         const modifiedResponse = await optionsArg.responseModifier({
           headers: res.getHeaders(),
           path: usedPath,
-          responseContent: fileString,
+          responseContent: fileBuffer,
           travelData,
         });
 
@@ -115,11 +114,15 @@ export class HandlerStatic extends Handler {
         }
 
         // responseContent
-        fileString = modifiedResponse.responseContent;
+        fileBuffer = modifiedResponse.responseContent;
       }
 
+      // lets finally deal with compression
+      const compressionResult = await this.compressor.maybeCompress(requestHeaders, fileBuffer);
+
       res.status(200);
-      res.write(Buffer.from(fileString, fileEncoding));
+      res.header('Content-Encoding', compressionResult.compressionMethod);
+      res.write(compressionResult.result);
       res.end();
     });
   }

ts/typedserver.classes.typedserver.ts

@@ -124,7 +124,7 @@ export class TypedServer {
         '/*',
         new servertools.HandlerStatic(this.options.serveDir, {
           responseModifier: async (responseArg) => {
-            let fileString = responseArg.responseContent;
+            let fileString = responseArg.responseContent.toString();
             if (plugins.path.parse(responseArg.path).ext === '.html') {
               const fileStringArray = fileString.split('<head>');
               if (this.options.injectReload && fileStringArray.length === 2) {
@@ -153,7 +153,7 @@ export class TypedServer {
             return {
               headers,
               path: responseArg.path,
-              responseContent: fileString,
+              responseContent: Buffer.from(fileString),
             };
           },
           serveIndexHtmlDefault: true,

ts/typedserver.plugins.ts

@@ -3,8 +3,9 @@ import * as http from 'http';
 import * as https from 'https';
 import * as net from 'net';
 import * as path from 'path';
+import * as zlib from 'zlib';
 
-export { http, https, net, path };
+export { http, https, net, path, zlib };
 
 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';

ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '3.0.9',
+  version: '3.0.10',
   description: 'easy serving of static files'
 }