use links partial

Author: mProjectsCode

exampleVault/Input Fields/Suggester.md

@@ -1,7 +1,8 @@
 ---
-fileSuggest: "[[Other/Example Notes/Example Note with Embeds.md|Example Note with Embeds]]"
-fileSuggest2: Example Note with E
 suggest: option 2
+fileSuggest: "[[Other/Example Notes/Example Note with Embeds.md|Example Note with Embeds]]"
+fileSuggest2: "[[Example Note with Embeds]]"
+fileSuggest3: Example Note with Embeds
 ---
 
 ### Simple Suggester
@@ -23,5 +24,9 @@ INPUT[suggester(optionQuery(#example-note), showcase):fileSuggest]
 ```
 
 ```meta-bind
-INPUT[suggester(optionQuery(#example-note), useLinks(false), showcase):fileSuggest2]
+INPUT[suggester(optionQuery(#example-note), useLinks(partial), showcase):fileSuggest2]
+```
+
+```meta-bind
+INPUT[suggester(optionQuery(#example-note), useLinks(false), showcase):fileSuggest3]
 ```

src/config/FieldConfigs.ts

@@ -185,6 +185,12 @@ export const InputFieldConfigs: Record<InputFieldType, InputFieldConfig> = {
 	},
 } as const;
 
+export enum UseLinksInputFieldArgumentValue {
+	TRUE = 'true',
+	PARTIAL = 'partial',
+	FALSE = 'false',
+}
+
 export type InputFieldArgumentConfig = FieldArgumentConfig<InputFieldArgumentType, InputFieldType>;
 
 export const InputFieldArgumentConfigs: Record<InputFieldArgumentType, InputFieldArgumentConfig> = {
@@ -418,7 +424,11 @@ export const InputFieldArgumentConfigs: Record<InputFieldArgumentType, InputFiel
 			[
 				{
 					name: 'value',
-					allowed: ['true', 'false'],
+					allowed: [
+						UseLinksInputFieldArgumentValue.TRUE,
+						UseLinksInputFieldArgumentValue.PARTIAL,
+						UseLinksInputFieldArgumentValue.FALSE,
+					],
 					description: '',
 				},
 			],

src/fields/fieldArguments/inputFieldArguments/arguments/UseLinksInputFieldArgument.ts

@@ -1,12 +1,65 @@
 import { AbstractInputFieldArgument } from '../AbstractInputFieldArgument';
 import { type ParsingResultNode } from '../../../../parsers/nomParsers/GeneralNomParsers';
-import { type InputFieldArgumentConfig, InputFieldArgumentConfigs } from '../../../../config/FieldConfigs';
+import {
+	type InputFieldArgumentConfig,
+	InputFieldArgumentConfigs,
+	UseLinksInputFieldArgumentValue,
+} from '../../../../config/FieldConfigs';
+import { ErrorLevel, MetaBindArgumentError } from '../../../../utils/errors/MetaBindErrors';
+import { DocsUtils } from '../../../../utils/DocsUtils';
+import { expectType, toEnumeration } from '../../../../utils/Utils';
+
+export function applyUseLinksArgument(
+	filePath: string,
+	fileName: string,
+	value: UseLinksInputFieldArgumentValue,
+): string {
+	if (value === UseLinksInputFieldArgumentValue.TRUE) {
+		return `[[${filePath}|${fileName}]]`;
+	} else if (value === UseLinksInputFieldArgumentValue.PARTIAL) {
+		return `[[${fileName}]]`;
+	} else {
+		expectType<UseLinksInputFieldArgumentValue.FALSE>(value);
+		return `${fileName}`;
+	}
+}
 
 export class UseLinksInputFieldArgument extends AbstractInputFieldArgument {
-	value: boolean = true;
+	value: UseLinksInputFieldArgumentValue = UseLinksInputFieldArgumentValue.TRUE;
 
 	_parseValue(value: ParsingResultNode[]): void {
-		this.value = value[0] === undefined || value[0]?.value.toLowerCase() === 'true';
+		/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+
+		const v = value[0]?.value.toLowerCase();
+		if (v === undefined) {
+			this.value = UseLinksInputFieldArgumentValue.TRUE;
+			return;
+		}
+
+		if (
+			v === UseLinksInputFieldArgumentValue.TRUE ||
+			v === UseLinksInputFieldArgumentValue.PARTIAL ||
+			v === UseLinksInputFieldArgumentValue.FALSE
+		) {
+			this.value = v;
+			return;
+		}
+
+		throw new MetaBindArgumentError({
+			errorLevel: ErrorLevel.WARNING,
+			effect: 'failed to set value for input field argument',
+			cause: `value of argument 'useLinks' must be one of ${toEnumeration(
+				[
+					UseLinksInputFieldArgumentValue.TRUE,
+					UseLinksInputFieldArgumentValue.PARTIAL,
+					UseLinksInputFieldArgumentValue.FALSE,
+				],
+				x => `'${x}'`,
+				', ',
+				'or',
+			)}`,
+			docs: [DocsUtils.linkToInputFieldArgument(this.getConfig().type)],
+		});
 	}
 
 	public getConfig(): InputFieldArgumentConfig {

src/fields/inputFields/fields/Suggester/SuggesterModalHelper.ts

@@ -1,20 +1,22 @@
 import { type MBLiteral } from '../../../../utils/Literal';
 import { type DataArray, type DataviewApi, type Literal } from 'obsidian-dataview';
-import { InputFieldArgumentType } from '../../../../config/FieldConfigs';
+import { InputFieldArgumentType, UseLinksInputFieldArgumentValue } from '../../../../config/FieldConfigs';
 import { type OptionInputFieldArgument } from '../../../fieldArguments/inputFieldArguments/arguments/OptionInputFieldArgument';
 import { type OptionQueryInputFieldArgument } from '../../../fieldArguments/inputFieldArguments/arguments/OptionQueryInputFieldArgument';
 import { Notice } from 'obsidian';
 import { SuggesterInputModal } from './SuggesterInputModal';
 import { type SuggesterLikeIFP, SuggesterOption } from './SuggesterHelper';
 import type MetaBindPlugin from '../../../../main';
 import { getDataViewPluginAPI } from '../../../../utils/ObsUtils';
+import { applyUseLinksArgument } from '../../../fieldArguments/inputFieldArguments/arguments/UseLinksInputFieldArgument';
+import { z } from 'zod';
 
 export function getSuggesterOptions(
 	plugin: MetaBindPlugin,
 	filePath: string,
 	optionArgs: OptionInputFieldArgument[],
 	optionQueryArgs: OptionQueryInputFieldArgument[],
-	useLinks: boolean,
+	useLinks: UseLinksInputFieldArgumentValue,
 ): SuggesterOption<MBLiteral>[] {
 	const options: SuggesterOption<MBLiteral>[] = [];
 
@@ -35,22 +37,24 @@ export function getSuggesterOptions(
 			return options;
 		}
 
+		const fileValidator = z.object({
+			name: z.string().min(1),
+			path: z.string().min(1),
+		});
+
 		for (const suggestOptionsQueryArgument of optionQueryArgs) {
 			const result: DataArray<Record<string, Literal>> = dv.pages(suggestOptionsQueryArgument.value, filePath);
 
 			result.forEach((file: Record<string, Literal>) => {
 				try {
-					// FIXME: this is unsafe, maybe add validation
 					const dvFile = file.file as { name: string; path: string };
 
-					if (useLinks) {
-						options.push(
-							new SuggesterOption<MBLiteral>(`[[${dvFile.path}|${dvFile.name}]]`, `file: ${dvFile.name}`),
-						);
-					} else {
-						// console.log(tFile);
-						options.push(new SuggesterOption<MBLiteral>(dvFile.name, `file: ${dvFile.name}`));
+					if (!fileValidator.safeParse(dvFile).success) {
+						return;
 					}
+
+					const link = applyUseLinksArgument(dvFile.path, dvFile.name, useLinks);
+					options.push(new SuggesterOption<MBLiteral>(link, `file: ${dvFile.name}`));
 				} catch (e) {
 					console.warn('meta-bind | error while computing suggest options', e);
 				}
@@ -67,14 +71,14 @@ export function getSuggesterOptionsForInputField(
 ): SuggesterOption<MBLiteral>[] {
 	const optionArgs = inputField.base.getArguments(InputFieldArgumentType.OPTION);
 	const optionQueryArgs = inputField.base.getArguments(InputFieldArgumentType.OPTION_QUERY);
-	const useLinksArgs = inputField.base.getArgument(InputFieldArgumentType.USE_LINKS);
+	const useLinksArg = inputField.base.getArgument(InputFieldArgumentType.USE_LINKS);
 	// in not present, we treat the use links argument as true
 	return getSuggesterOptions(
 		plugin,
 		inputField.base.getFilePath(),
 		optionArgs,
 		optionQueryArgs,
-		useLinksArgs === undefined || useLinksArgs.value,
+		useLinksArg === undefined ? UseLinksInputFieldArgumentValue.TRUE : useLinksArg.value,
 	);
 }
 

src/utils/Utils.ts

@@ -167,3 +167,30 @@ export function openURL(link: string): void {
 }
 
 export type Tuple<T> = [T, ...T[]];
+
+export function toEnumeration(
+	arr: string[],
+	map: (x: string) => string,
+	separator: string = ', ',
+	lastSeparator: string = 'and',
+): string {
+	if (arr.length === 0) {
+		return '';
+	}
+
+	arr = arr.map(map);
+
+	if (arr.length === 1) {
+		return arr[0];
+	}
+
+	if (arr.length === 2) {
+		return `${arr[0]} ${lastSeparator} ${arr[1]}`;
+	}
+
+	return `${arr.slice(0, -1).join(separator)} ${lastSeparator} ${arr.slice(-1)}`;
+}
+
+export function expectType<T>(_: T): void {
+	// no op
+}