@eleven-am/pondsocket 0.1.62 → 0.1.64

package/matcher/matcher.js

@@ -1,91 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAddress = void 0;
-/**
- * @desc Returns the {key: value} matches of a string
- * @param path - the string to create the regex from
- * @param address - the pattern to match
- *
- * @example
- * /api/:id should match /api/123 and return { id: 123 }
- * /api/:id/:name should match /api/123/abc and return { id: 123, name: abc }
- * hello:id should match hello:123 and return { id: 123 }
- * @private
- */
-function matchPath(path, address) {
-    const pathParts = path.split('/');
-    const addressParts = address.split('/');
-    const params = {};
-    const length = Math.max(pathParts.length, addressParts.length);
-    for (let i = 0; i < length; i++) {
-        const pathPart = pathParts[i];
-        const addressPart = addressParts[i];
-        if (pathPart === undefined || addressPart === undefined) {
-            return null;
-        }
-        else if (pathPart === '*') {
-            return params;
+function pathToRegexp(path) {
+    const parts = path.split('/');
+    const regexpParts = parts.map((part) => {
+        if (part.startsWith(':')) {
+            return '([^/]+)';
         }
-        else if (pathPart.startsWith(':')) {
-            params[pathPart.slice(1)] = addressPart;
+        else if (part === '*') {
+            return '(.*)';
         }
-        else if (pathPart !== addressPart) {
-            return null;
-        }
-    }
-    return params;
+        return part;
+    });
+    return new RegExp(`^${regexpParts.join('/')}$`);
 }
-/**
- * @desc Given a Regex expression it returns an empty object if the address matches
- * @param regex - The regex to match the address against
- * @param address - The address ot match
- */
-function matchRegex(regex, address) {
-    if (address.match(regex)) {
+function getParams(path, route) {
+    const regexp = pathToRegexp(route);
+    const match = path.match(regexp);
+    if (!match) {
+        return null;
+    }
+    const cleanRoute = route.replace(/:/g, '');
+    const cleanMatch = cleanRoute.match(regexp);
+    if (!cleanMatch) {
+        return null;
+    }
+    const keys = cleanMatch.slice(1).filter((s) => s !== '');
+    const values = match.slice(1).filter((s) => s !== '');
+    if (keys.length !== values.length) {
         return {};
     }
-    return null;
+    return keys.reduce((params, key, index) => {
+        if (key === '*') {
+            params[key] = `/${values.slice(index).join('/')}`.replace(/\/+/g, '/');
+            return params;
+        }
+        params[key] = values[index];
+        return params;
+    }, {});
 }
-/**
- * @desc Creates an object from the params of a path
- * @param address - the path to create the object from
- *
- * @example
- * /api/id?name=abc should return { name: 'abc' }
- * /api/id?name=abc&age=123 should return { name: 'abc', age: '123' }
- */
-function getQuery(address) {
-    const obj = {};
-    const params = address.split('?')[1];
-    if (params) {
-        params.split('&').forEach((param) => {
-            const [key, value] = param.split('=');
-            obj[key] = value;
-        });
+function getQuery(query) {
+    if (!query) {
+        return {};
     }
-    return obj;
+    const parts = query.split('&');
+    return parts.reduce((params, part) => {
+        const [key, value] = part.split('=');
+        params[key] = value;
+        return params;
+    }, {});
 }
-/**
- * @desc Generates a pond request resolver object
- * @param path - the path to resolve
- * @param address - the address to resolve
- */
-function parseAddress(path, address) {
-    let params;
-    const [paramsPath] = address.split('?');
-    if (typeof path === 'string') {
-        params = matchPath(path, paramsPath);
-        if (params === null) {
+function parseAddress(route, address) {
+    if (route instanceof RegExp) {
+        const match = address.match(route);
+        if (!match) {
             return null;
         }
+        return {
+            params: {},
+            query: {},
+        };
     }
-    else {
-        params = matchRegex(path, paramsPath);
-        if (params === null) {
-            return null;
-        }
+    const [path, queryParams] = address.split('?');
+    const params = getParams(path, route);
+    if (!params) {
+        return null;
     }
-    const query = getQuery(address);
+    const query = getQuery(queryParams);
     return {
         params,
         query,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",