feat(hf): add finder

Author: mathcovax

integration/finder/index.test.ts

@@ -0,0 +1,24 @@
+import { dataParserFinder, defaultResearchers } from "@duplojs/data-parser-tools/finder";
+import { DPE } from "@duplojs/utils";
+
+describe("finder integration", () => {
+	it("exposes the finder API from the package root export", () => {
+		const target = DPE.number();
+		const schema = DPE.object({
+			profile: DPE.object({
+				ids: DPE.array(target),
+			}),
+		});
+
+		const result = dataParserFinder(
+			schema,
+			(dataParser) => dataParser === target,
+			{
+				researchers: [...defaultResearchers],
+				ignore: new Set(),
+			},
+		);
+
+		expect(result).toEqual([target]);
+	});
+});

package.json

@@ -50,6 +50,11 @@
       "import": "./dist/toDataParser/index.mjs",
       "require": "./dist/toDataParser/index.cjs",
       "types": "./dist/toDataParser/index.d.ts"
+    },
+    "./finder": {
+      "import": "./dist/finder/index.mjs",
+      "require": "./dist/finder/index.cjs",
+      "types": "./dist/finder/index.d.ts"
     }
   },
   "files": [

scripts/finder/index.ts

@@ -0,0 +1,69 @@
+import { A, type DP } from "@duplojs/utils";
+import { type ResearcherParams, type createResearcher } from "./researcher";
+
+export * from "./researcher";
+
+export interface DataParserFinderParams {
+	researchers: ReturnType<typeof createResearcher>[];
+	ignore?: Set<DP.DataParser>;
+	continueAfterMatch?: boolean;
+}
+
+export function dataParserFinder<
+	GenericPredicate extends DP.DataParsers,
+>(
+	dataParser: DP.DataParser,
+	predicate: (dataParser: DP.DataParsers) => dataParser is GenericPredicate,
+	params: DataParserFinderParams,
+): GenericPredicate[];
+
+export function dataParserFinder(
+	dataParser: DP.DataParser,
+	predicate: (dataParser: DP.DataParsers) => boolean,
+	params: DataParserFinderParams,
+): DP.DataParsers[];
+
+export function dataParserFinder(
+	dataParser: DP.DataParser,
+	predicate: (dataParser: DP.DataParsers) => boolean,
+	params: DataParserFinderParams,
+) {
+	const result: DP.DataParsers[] = [];
+	const ignoreContext = params.ignore ?? new Set();
+
+	if (ignoreContext.has(dataParser)) {
+		return result;
+	}
+
+	ignoreContext.add(dataParser);
+
+	if (predicate(dataParser)) {
+		result.push(dataParser);
+
+		if (params.continueAfterMatch !== true) {
+			return result;
+		}
+	}
+
+	const researcherParams: ResearcherParams = {
+		find(dataParser) {
+			result.push(
+				...dataParserFinder(
+					dataParser,
+					predicate,
+					{
+						...params,
+						ignore: ignoreContext,
+					},
+				),
+			);
+		},
+	};
+
+	A.map(
+		params.researchers,
+		(researcher) => void researcher(dataParser, researcherParams),
+	);
+
+	return result;
+}

scripts/finder/researcher/create.ts

@@ -0,0 +1,31 @@
+import { type DP } from "@duplojs/utils";
+
+export interface ResearcherParams {
+	find(dataParser: DP.DataParser): void;
+}
+
+export function createResearcher<
+	GenericPredicate extends DP.DataParsers,
+>(
+	predicate: (dataParser: DP.DataParsers) => dataParser is GenericPredicate,
+	researcher: (dataParser: GenericPredicate, params: ResearcherParams) => void,
+): (dataParser: DP.DataParser, params: ResearcherParams) => void;
+
+export function createResearcher(
+	predicate: (dataParser: DP.DataParsers) => boolean,
+	researcher: (dataParser: DP.DataParser, params: ResearcherParams) => void,
+): (dataParser: DP.DataParser, params: ResearcherParams) => void;
+
+export function createResearcher(
+	predicate: (dataParser: DP.DataParsers) => boolean,
+	researcher: (dataParser: DP.DataParser, params: ResearcherParams) => void,
+) {
+	return (
+		dataParser: DP.DataParser,
+		params: ResearcherParams,
+	) => {
+		if (predicate(dataParser)) {
+			researcher(dataParser, params);
+		}
+	};
+}

scripts/finder/researcher/defaults/array.ts

@@ -0,0 +1,9 @@
+import { DP } from "@duplojs/utils";
+import { createResearcher } from "../create";
+
+export const arrayResearcher = createResearcher(
+	DP.arrayKind.has,
+	(dataParser, params) => {
+		params.find(dataParser.definition.element);
+	},
+);

scripts/finder/researcher/defaults/index.ts

@@ -0,0 +1,41 @@
+export * from "./array";
+export * from "./lazy";
+export * from "./nullable";
+export * from "./object";
+export * from "./optional";
+export * from "./pipe";
+export * from "./record";
+export * from "./recover";
+export * from "./templateLiteral";
+export * from "./transform";
+export * from "./tuple";
+export * from "./union";
+
+import type { createResearcher } from "../create";
+import { arrayResearcher } from "./array";
+import { lazyResearcher } from "./lazy";
+import { nullableResearcher } from "./nullable";
+import { objectResearcher } from "./object";
+import { optionalResearcher } from "./optional";
+import { pipeResearcher } from "./pipe";
+import { recordResearcher } from "./record";
+import { recoverResearcher } from "./recover";
+import { templateLiteralResearcher } from "./templateLiteral";
+import { transformResearcher } from "./transform";
+import { tupleResearcher } from "./tuple";
+import { unionResearcher } from "./union";
+
+export const defaultResearchers = [
+	arrayResearcher,
+	lazyResearcher,
+	nullableResearcher,
+	objectResearcher,
+	optionalResearcher,
+	pipeResearcher,
+	recordResearcher,
+	recoverResearcher,
+	templateLiteralResearcher,
+	transformResearcher,
+	tupleResearcher,
+	unionResearcher,
+] as const satisfies readonly ReturnType<typeof createResearcher>[];

scripts/finder/researcher/defaults/lazy.ts

@@ -0,0 +1,9 @@
+import { DP } from "@duplojs/utils";
+import { createResearcher } from "../create";
+
+export const lazyResearcher = createResearcher(
+	DP.lazyKind.has,
+	(dataParser, params) => {
+		params.find(dataParser.definition.getter.value);
+	},
+);

scripts/finder/researcher/defaults/nullable.ts

@@ -0,0 +1,9 @@
+import { DP } from "@duplojs/utils";
+import { createResearcher } from "../create";
+
+export const nullableResearcher = createResearcher(
+	DP.nullableKind.has,
+	(dataParser, params) => {
+		params.find(dataParser.definition.inner);
+	},
+);

scripts/finder/researcher/defaults/object.ts

@@ -0,0 +1,13 @@
+import { A, DP, O, pipe } from "@duplojs/utils";
+import { createResearcher } from "../create";
+
+export const objectResearcher = createResearcher(
+	DP.objectKind.has,
+	(dataParser, params) => {
+		pipe(
+			dataParser.definition.shape,
+			O.values,
+			A.map(params.find),
+		);
+	},
+);

scripts/finder/researcher/defaults/optional.ts

@@ -0,0 +1,9 @@
+import { DP } from "@duplojs/utils";
+import { createResearcher } from "../create";
+
+export const optionalResearcher = createResearcher(
+	DP.optionalKind.has,
+	(dataParser, params) => {
+		params.find(dataParser.definition.inner);
+	},
+);