@eleven-am/pondsocket 0.1.62 → 0.1.63

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.63",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",

package/types.d.ts

@@ -4,7 +4,6 @@ import { WebSocketServer } from 'ws';
 
 type Unsubscribe = () => void;
 
-export type default_t<T = any> = Record<string, T>;
 type IsParam<Path> = Path extends `:${infer Param}` ? Param : never;
 
 type FilteredParams<Path> = Path extends `${infer First}/${infer Second}`
@@ -22,7 +21,12 @@ type EventParams<Path> = {
     params: Params<Path>;
 }
 
-type PondObject = default_t;
+type Primitives = number | string | boolean | null | undefined;
+
+type PondObject = {
+    [key: string]: Primitives | PondObject | PondObject[];
+}
+
 type PondPresence = PondObject;
 type PondMessage = PondObject;
 type PondAssigns = PondObject;
@@ -52,13 +56,6 @@ type IncomingConnection<Path> = EventParams<Path> & {
     address: string;
 }
 
-interface LeaveEvent {
-    userId: string;
-    assigns: PondAssigns;
-}
-
-type LeaveCallback = (event: LeaveEvent) => void;
-
 interface UserData {
     assigns: PondAssigns;
     presence: PondPresence;
@@ -482,12 +479,6 @@ export declare class PondChannel {
      *});
      */
     broadcast (event: string, payload: PondMessage, channelName?: string): void;
-
-    /**
-     * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
-     * @param callback - The callback to execute when a user leaves
-     */
-    public onLeave (callback: LeaveCallback): void;
 }
 
 declare class PondSocket {