@dynamic-labs/utils 0.0.0-exp20240808.0

package/src/template/template.d.ts

@@ -0,0 +1,18 @@
+type ExtractPlaceholders<T extends string> = T extends `${infer _Start}{{${infer Placeholder}}}${infer Rest}` ? Placeholder | ExtractPlaceholders<Rest> : never;
+/**
+ * Creates a template function that replaces placeholders with corresponding values from a data object.
+ * @param {string} templateText - The template string containing placeholders in the form {{placeholder}}.
+ * @returns {(data) => string} - A function that replaces the placeholders with the values from the data object.
+ *
+ * @example
+ * // Basic usage
+ * const compiled = template('Test text {{placeholder}} value');
+ * console.log(compiled({ placeholder: 'test' })); // Output: 'Test text test value'
+ *
+ * @example
+ * // Multiple placeholders
+ * const compiled = template('Test text {{placeholder}} value {{placeholder2}}');
+ * console.log(compiled({ placeholder: 'test', placeholder2: 'test2' })); // Output: 'Test text test value test2'
+ */
+export declare const template: <T extends string>(templateText: T) => (data: { [key in ExtractPlaceholders<T>]: string; }) => string;
+export {};

package/src/template/template.js

@@ -0,0 +1,21 @@
+'use client'
+/**
+ * Creates a template function that replaces placeholders with corresponding values from a data object.
+ * @param {string} templateText - The template string containing placeholders in the form {{placeholder}}.
+ * @returns {(data) => string} - A function that replaces the placeholders with the values from the data object.
+ *
+ * @example
+ * // Basic usage
+ * const compiled = template('Test text {{placeholder}} value');
+ * console.log(compiled({ placeholder: 'test' })); // Output: 'Test text test value'
+ *
+ * @example
+ * // Multiple placeholders
+ * const compiled = template('Test text {{placeholder}} value {{placeholder2}}');
+ * console.log(compiled({ placeholder: 'test', placeholder2: 'test2' })); // Output: 'Test text test value test2'
+ */
+const template = (templateText) => {
+    return (data) => templateText.replace(/{{(\w+?)}}/g, (match, key) => key in data ? data[key] : match);
+};
+
+export { template };

package/src/trimEnd/index.d.ts

@@ -0,0 +1 @@
+export { trimEnd } from './trimEnd';

package/src/trimEnd/trimEnd.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const trimEnd = (text, char = '') => {
+    let endIndex = text.length - 1;
+    while (endIndex >= 0 && text[endIndex] === char) {
+        endIndex--;
+    }
+    return text.slice(0, endIndex + 1);
+};
+
+exports.trimEnd = trimEnd;

package/src/trimEnd/trimEnd.d.ts

@@ -0,0 +1 @@
+export declare const trimEnd: (text: string, char?: string) => string;

package/src/trimEnd/trimEnd.js

@@ -0,0 +1,10 @@
+'use client'
+const trimEnd = (text, char = '') => {
+    let endIndex = text.length - 1;
+    while (endIndex >= 0 && text[endIndex] === char) {
+        endIndex--;
+    }
+    return text.slice(0, endIndex + 1);
+};
+
+export { trimEnd };

package/src/uniq/index.d.ts

@@ -0,0 +1 @@
+export { uniq } from './uniq';

package/src/uniq/uniq.cjs

@@ -0,0 +1,33 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Removes duplicate elements from an array.
+ *
+ * @param {T[]} array - The array to filter for unique elements.
+ * @template T - The type of elements in the array.
+ * @returns {T[]} A new array containing only the unique elements of the given array.
+ *
+ * @example
+ * // returns [1, 2, 3, 4, 5]
+ * uniq([1, 2, 2, 3, 4, 4, 5]);
+ *
+ * @example
+ * // returns ['apple', 'banana', 'orange']
+ * uniq(['apple', 'banana', 'apple', 'orange']);
+ *
+ */
+const uniq = (array) => {
+    const seen = new Set();
+    return array.filter((item) => {
+        if (seen.has(item)) {
+            return false;
+        }
+        seen.add(item);
+        return true;
+    });
+};
+
+exports.uniq = uniq;

package/src/uniq/uniq.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Removes duplicate elements from an array.
+ *
+ * @param {T[]} array - The array to filter for unique elements.
+ * @template T - The type of elements in the array.
+ * @returns {T[]} A new array containing only the unique elements of the given array.
+ *
+ * @example
+ * // returns [1, 2, 3, 4, 5]
+ * uniq([1, 2, 2, 3, 4, 4, 5]);
+ *
+ * @example
+ * // returns ['apple', 'banana', 'orange']
+ * uniq(['apple', 'banana', 'apple', 'orange']);
+ *
+ */
+export declare const uniq: <T>(array: T[]) => T[];

package/src/uniq/uniq.js

@@ -0,0 +1,29 @@
+'use client'
+/**
+ * Removes duplicate elements from an array.
+ *
+ * @param {T[]} array - The array to filter for unique elements.
+ * @template T - The type of elements in the array.
+ * @returns {T[]} A new array containing only the unique elements of the given array.
+ *
+ * @example
+ * // returns [1, 2, 3, 4, 5]
+ * uniq([1, 2, 2, 3, 4, 4, 5]);
+ *
+ * @example
+ * // returns ['apple', 'banana', 'orange']
+ * uniq(['apple', 'banana', 'apple', 'orange']);
+ *
+ */
+const uniq = (array) => {
+    const seen = new Set();
+    return array.filter((item) => {
+        if (seen.has(item)) {
+            return false;
+        }
+        seen.add(item);
+        return true;
+    });
+};
+
+export { uniq };

package/src/wrapMethodWithCallback/index.d.ts

@@ -0,0 +1 @@
+export { wrapMethodWithCallback } from './wrapMethodWithCallback';

package/src/wrapMethodWithCallback/wrapMethodWithCallback.cjs

@@ -0,0 +1,47 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Wraps an existing method of an object with a callback function. This allows for additional
+ * processing or behavior to be executed around the original method. The original method is
+ * called within the callback, and its parameters and return value can be accessed and/or modified.
+ *
+ * @template T - The type of the object whose method is being wrapped.
+ * @template K - The key type of the method within the object.
+ * @template F - The type of the function, inferred from the method of the object.
+ *
+ * @param {T} obj - The object containing the method to be wrapped.
+ * @param {K} key - The key of the method in the object to be wrapped.
+ * @param {(original: F, ...args: Parameters<F>) => ReturnType<F>} callback - The callback
+ *        function to wrap around the original method. It receive1`s the original method and its
+ *        parameters as arguments.
+ *
+ * @returns {void} - The function does not return a value; it modifies the method of the object in place.
+ *
+ * @example
+ * // Example usage
+ * const myObject = {
+ *   greet(name) {
+ *     return `Hello, ${name}!`;
+ *   }
+ * };
+ *
+ * wrapMethodWithCallback(myObject, 'greet', (original, ...args) => {
+ *   console.log('Greet method called with args:', args);
+ *   return original(...args).toUpperCase();
+ * });
+ *
+ * console.log(myObject.greet('Alice')); // Logs: 'Greet method called with args: ["Alice"]'
+ *                                      // Returns: 'HELLO, ALICE!'
+ */
+const wrapMethodWithCallback = (obj, key, callback) => {
+    const original = obj[key];
+    const boundOriginal = original.bind(obj);
+    Object.assign(obj, {
+        [key]: (...args) => callback(boundOriginal, ...args),
+    });
+};
+
+exports.wrapMethodWithCallback = wrapMethodWithCallback;

package/src/wrapMethodWithCallback/wrapMethodWithCallback.d.ts

@@ -0,0 +1,36 @@
+type Method = (...args: any[]) => any;
+/**
+ * Wraps an existing method of an object with a callback function. This allows for additional
+ * processing or behavior to be executed around the original method. The original method is
+ * called within the callback, and its parameters and return value can be accessed and/or modified.
+ *
+ * @template T - The type of the object whose method is being wrapped.
+ * @template K - The key type of the method within the object.
+ * @template F - The type of the function, inferred from the method of the object.
+ *
+ * @param {T} obj - The object containing the method to be wrapped.
+ * @param {K} key - The key of the method in the object to be wrapped.
+ * @param {(original: F, ...args: Parameters<F>) => ReturnType<F>} callback - The callback
+ *        function to wrap around the original method. It receive1`s the original method and its
+ *        parameters as arguments.
+ *
+ * @returns {void} - The function does not return a value; it modifies the method of the object in place.
+ *
+ * @example
+ * // Example usage
+ * const myObject = {
+ *   greet(name) {
+ *     return `Hello, ${name}!`;
+ *   }
+ * };
+ *
+ * wrapMethodWithCallback(myObject, 'greet', (original, ...args) => {
+ *   console.log('Greet method called with args:', args);
+ *   return original(...args).toUpperCase();
+ * });
+ *
+ * console.log(myObject.greet('Alice')); // Logs: 'Greet method called with args: ["Alice"]'
+ *                                      // Returns: 'HELLO, ALICE!'
+ */
+export declare const wrapMethodWithCallback: <T extends object, K extends { [P in keyof T]: T[P] extends Method ? P : never; }[keyof T], F extends Method = T[K] extends Method ? T[K] : never>(obj: T, key: K, callback: (original: F, ...args: Parameters<F>) => ReturnType<F>) => void;
+export {};

package/src/wrapMethodWithCallback/wrapMethodWithCallback.js

@@ -0,0 +1,43 @@
+'use client'
+/**
+ * Wraps an existing method of an object with a callback function. This allows for additional
+ * processing or behavior to be executed around the original method. The original method is
+ * called within the callback, and its parameters and return value can be accessed and/or modified.
+ *
+ * @template T - The type of the object whose method is being wrapped.
+ * @template K - The key type of the method within the object.
+ * @template F - The type of the function, inferred from the method of the object.
+ *
+ * @param {T} obj - The object containing the method to be wrapped.
+ * @param {K} key - The key of the method in the object to be wrapped.
+ * @param {(original: F, ...args: Parameters<F>) => ReturnType<F>} callback - The callback
+ *        function to wrap around the original method. It receive1`s the original method and its
+ *        parameters as arguments.
+ *
+ * @returns {void} - The function does not return a value; it modifies the method of the object in place.
+ *
+ * @example
+ * // Example usage
+ * const myObject = {
+ *   greet(name) {
+ *     return `Hello, ${name}!`;
+ *   }
+ * };
+ *
+ * wrapMethodWithCallback(myObject, 'greet', (original, ...args) => {
+ *   console.log('Greet method called with args:', args);
+ *   return original(...args).toUpperCase();
+ * });
+ *
+ * console.log(myObject.greet('Alice')); // Logs: 'Greet method called with args: ["Alice"]'
+ *                                      // Returns: 'HELLO, ALICE!'
+ */
+const wrapMethodWithCallback = (obj, key, callback) => {
+    const original = obj[key];
+    const boundOriginal = original.bind(obj);
+    Object.assign(obj, {
+        [key]: (...args) => callback(boundOriginal, ...args),
+    });
+};
+
+export { wrapMethodWithCallback };