@smythos/sre 1.6.8 → 1.6.10

package/src/Core/DummyConnector.ts

@@ -1,49 +1,49 @@
-import { Logger } from '../helpers/Log.helper';
-import { getFormattedStackTrace, printStackTrace } from '../utils';
-
-/**
- * DummyConnector is a placeholder for unimplemented connectors, it logs a warning when a method is called in order to help developers identify missing connectors
- */
-export const DummyConnector: any = (name: string) => {
-    const logger = Logger(`DummyConnector<${name}>`);
-    return new Proxy(
-        {},
-        {
-            get: function (target, prop, receiver) {
-                //check if we are accessing the valid property
-                if (prop === 'valid') {
-                    return false; //when DummyConnector is used it means that the main connector failed to load
-                }
-
-                // Check if the property being accessed is a function
-                if (typeof target[prop] === 'function') {
-                    return target[prop];
-                } else {
-                    // Return a function that logs "unavailable"
-                    return function (...args: any[]) {
-                        const argsString =
-                            args.length > 0
-                                ? args
-                                      .map((arg) => {
-                                          if (typeof arg === 'object') return JSON.stringify(arg, null, 0).slice(0, 50) + '...';
-                                          if (typeof arg === 'string') return `"${arg.slice(0, 50)}..."`;
-                                          if (typeof arg === 'number') return arg.toString();
-                                          if (typeof arg === 'boolean') return arg.toString();
-                                          if (typeof arg === 'function') return arg.toString();
-                                          if (typeof arg === 'symbol') return arg.toString();
-                                          if (typeof arg === 'undefined') return 'undefined';
-
-                                          return String(arg);
-                                      })
-                                      .join(', ')
-                                : '(no arguments)';
-
-                        logger.warn(`[!!] Unimplemented Connector tried to call: ${name}.${prop.toString()}(${argsString})`);
-
-                        printStackTrace(logger, 3, 1); //the argument 1 means that we skip one more strack element because we are calling printStackTrace from an anonymous function
-                    };
-                }
-            },
-        },
-    );
-};
+import { Logger } from '../helpers/Log.helper';
+import { getFormattedStackTrace, printStackTrace } from '../utils';
+
+/**
+ * DummyConnector is a placeholder for unimplemented connectors, it logs a warning when a method is called in order to help developers identify missing connectors
+ */
+export const DummyConnector: any = (name: string) => {
+    const logger = Logger(`DummyConnector<${name}>`);
+    return new Proxy(
+        {},
+        {
+            get: function (target, prop, receiver) {
+                //check if we are accessing the valid property
+                if (prop === 'valid') {
+                    return false; //when DummyConnector is used it means that the main connector failed to load
+                }
+
+                // Check if the property being accessed is a function
+                if (typeof target[prop] === 'function') {
+                    return target[prop];
+                } else {
+                    // Return a function that logs "unavailable"
+                    return function (...args: any[]) {
+                        const argsString =
+                            args.length > 0
+                                ? args
+                                      .map((arg) => {
+                                          if (typeof arg === 'object') return JSON.stringify(arg, null, 0).slice(0, 50) + '...';
+                                          if (typeof arg === 'string') return `"${arg.slice(0, 50)}..."`;
+                                          if (typeof arg === 'number') return arg.toString();
+                                          if (typeof arg === 'boolean') return arg.toString();
+                                          if (typeof arg === 'function') return arg.toString();
+                                          if (typeof arg === 'symbol') return arg.toString();
+                                          if (typeof arg === 'undefined') return 'undefined';
+
+                                          return String(arg);
+                                      })
+                                      .join(', ')
+                                : '(no arguments)';
+
+                        logger.warn(`[!!] Unimplemented Connector tried to call: ${name}.${prop.toString()}(${argsString})`);
+
+                        printStackTrace(logger, 3, 1); //the argument 1 means that we skip one more strack element because we are calling printStackTrace from an anonymous function
+                    };
+                }
+            },
+        },
+    );
+};

package/src/Core/HookService.ts

@@ -1,105 +1,105 @@
-// Type definition for hook callbacks
-type HookCallback = (...args: any[]) => void;
-
-// Store hooks in a map where each hook name can have multiple callbacks
-const hooks: { [key: string]: HookCallback[] } = {};
-
-export class HookService {
-    /**
-     * Register a new hook callback for a given hook name
-     * @param hookName The name of the hook to register
-     * @param callback The callback function to execute when the hook is triggered
-     */
-    static register(hookName: string, callback: HookCallback): void {
-        if (typeof callback !== 'function') {
-            throw new Error('Hook callback must be a function');
-        }
-
-        if (!hooks[hookName]) {
-            hooks[hookName] = [];
-        }
-
-        hooks[hookName].push(callback);
-    }
-
-    static trigger(hookName: string, ...args: any[]) {
-        if (hooks[hookName]) {
-            hooks[hookName].forEach((callback) => callback(...args));
-        }
-    }
-}
-
-/**
- * Decorator function that executes registered hooks before the decorated method
- * @param hookName The name of the hook to trigger
- */
-export function hook(hookName: string) {
-    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = function (...args: any[]) {
-            // Execute all registered hooks for this hook name
-            if (hooks[hookName]) {
-                hooks[hookName].forEach((callback) => {
-                    callback.apply(this, args);
-                });
-            }
-
-            // Call the original method
-            return originalMethod.apply(this, args);
-        };
-
-        return descriptor;
-    };
-}
-
-/**
- * Decorator function that executes registered hooks asynchronously before the decorated method
- * @param hookName The name of the hook to trigger
- */
-export function hookAsync(hookName: string) {
-    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = async function (...args: any[]) {
-            // Execute all registered hooks for this hook name
-            if (hooks[hookName]) {
-                // Wait for all hooks to complete before proceeding
-                await Promise.all(hooks[hookName].map((callback) => callback.apply(this, args)));
-            }
-
-            // Call the original method
-            return originalMethod.apply(this, args);
-        };
-
-        return descriptor;
-    };
-}
-
-/**
- * Decorator function that executes registered hooks asynchronously before the decorated method
- * @param hookName The name of the hook to trigger
- * @param contextFn Optional function to extract additional context from the class instance
- */
-export function hookAsyncWithContext(hookName: string, contextFn?: (instance: any) => Record<string, any>) {
-    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = async function (...args: any[]) {
-            // Execute all registered hooks for this hook name
-            if (hooks[hookName]) {
-                // Get additional context if contextFn is provided
-                const additionalContext = typeof contextFn === 'function' ? await contextFn(this) : {};
-
-                // Wait for all hooks to complete before proceeding
-                // We need to prepend the additional context before the args; otherwise, optional parameters may cause incorrect argument mapping.
-                await Promise.all(hooks[hookName].map((callback) => callback.apply(this, [additionalContext, ...args])));
-            }
-
-            // Call the original method
-            return originalMethod.apply(this, args);
-        };
-
-        return descriptor;
-    };
-}
+// Type definition for hook callbacks
+type HookCallback = (...args: any[]) => void;
+
+// Store hooks in a map where each hook name can have multiple callbacks
+const hooks: { [key: string]: HookCallback[] } = {};
+
+export class HookService {
+    /**
+     * Register a new hook callback for a given hook name
+     * @param hookName The name of the hook to register
+     * @param callback The callback function to execute when the hook is triggered
+     */
+    static register(hookName: string, callback: HookCallback): void {
+        if (typeof callback !== 'function') {
+            throw new Error('Hook callback must be a function');
+        }
+
+        if (!hooks[hookName]) {
+            hooks[hookName] = [];
+        }
+
+        hooks[hookName].push(callback);
+    }
+
+    static trigger(hookName: string, ...args: any[]) {
+        if (hooks[hookName]) {
+            hooks[hookName].forEach((callback) => callback(...args));
+        }
+    }
+}
+
+/**
+ * Decorator function that executes registered hooks before the decorated method
+ * @param hookName The name of the hook to trigger
+ */
+export function hook(hookName: string) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+
+        descriptor.value = function (...args: any[]) {
+            // Execute all registered hooks for this hook name
+            if (hooks[hookName]) {
+                hooks[hookName].forEach((callback) => {
+                    callback.apply(this, args);
+                });
+            }
+
+            // Call the original method
+            return originalMethod.apply(this, args);
+        };
+
+        return descriptor;
+    };
+}
+
+/**
+ * Decorator function that executes registered hooks asynchronously before the decorated method
+ * @param hookName The name of the hook to trigger
+ */
+export function hookAsync(hookName: string) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+
+        descriptor.value = async function (...args: any[]) {
+            // Execute all registered hooks for this hook name
+            if (hooks[hookName]) {
+                // Wait for all hooks to complete before proceeding
+                await Promise.all(hooks[hookName].map((callback) => callback.apply(this, args)));
+            }
+
+            // Call the original method
+            return originalMethod.apply(this, args);
+        };
+
+        return descriptor;
+    };
+}
+
+/**
+ * Decorator function that executes registered hooks asynchronously before the decorated method
+ * @param hookName The name of the hook to trigger
+ * @param contextFn Optional function to extract additional context from the class instance
+ */
+export function hookAsyncWithContext(hookName: string, contextFn?: (instance: any) => Record<string, any>) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+
+        descriptor.value = async function (...args: any[]) {
+            // Execute all registered hooks for this hook name
+            if (hooks[hookName]) {
+                // Get additional context if contextFn is provided
+                const additionalContext = typeof contextFn === 'function' ? await contextFn(this) : {};
+
+                // Wait for all hooks to complete before proceeding
+                // We need to prepend the additional context before the args; otherwise, optional parameters may cause incorrect argument mapping.
+                await Promise.all(hooks[hookName].map((callback) => callback.apply(this, [additionalContext, ...args])));
+            }
+
+            // Call the original method
+            return originalMethod.apply(this, args);
+        };
+
+        return descriptor;
+    };
+}