chore: Refactor cachedFunction to use selectorToCacheKey

Author: tomerh2001

src/index.ts

@@ -1,31 +1,19 @@
 
+import _ from 'lodash';
 import type {CachedFunctionOptions} from './index.d';
-import type {AnyFunction} from './paths.d';
+import type {AnyFunction, ArgumentPaths} from './paths.d';
 
-export function cachedFunction<F extends AnyFunction>(function_: F, options: CachedFunctionOptions<F>) {
-	console.log(options);
-	return function_;
+export function selectorToCacheKey<F extends AnyFunction>(arguments_: Parameters<F>, selector: ArgumentPaths<F>) {
+	const selectors = _.castArray(selector);
+	const values = _.at(arguments_, selectors);
+	const result = _.zipObject(selectors, values);
+	return JSON.stringify(result);
 }
 
-/** TEST */
-type Person = {
-	name: string;
-	age: number;
-	address: {
-		city: string;
-		zip: number;
+export function cachedFunction<F extends AnyFunction>(function_: F, options: CachedFunctionOptions<F>) {
+	return (...arguments_: Parameters<F>): ReturnType<F> => {
+		const cacheKey = selectorToCacheKey(arguments_, options.selector);
+		console.log({cacheKey});
+		return function_(...arguments_);
 	};
-};
-
-const person: Person = {
-	name: 'John Doe',
-	age: 30,
-	address: {
-		city: 'New York',
-		zip: 10_001,
-	},
-};
-
-cachedFunction((person: Person) => person.name, {
-	selector: person => person.name,
-});
+}

src/paths.d.ts

@@ -34,15 +34,4 @@ export type Paths<T> = T extends Record<string, unknown>
  * @typeparam F - The function type.
  * @typeparam Paths - The paths of the arguments of the function type.
  */
-export type ArgumentPaths1<F extends AnyFunction> = SingleOrArray<Paths<Parameters<F>>>;
-
-/**
- * Represents a function that takes arguments of type `Parameters<F>` and returns `ArgumentPaths1<F>`.
- */
-export type ArgumentPaths2<F extends AnyFunction> = (...arguments_: Parameters<F>) => ArgumentPaths1<F>;
-
-/**
- * Represents the argument paths for a given function type.
- * @template F - The function type.
- */
-export type ArgumentPaths<F extends AnyFunction> = ArgumentPaths1<F> | ArgumentPaths2<F>;
+export type ArgumentPaths<F extends AnyFunction> = SingleOrArray<Paths<Parameters<F>>>;