@octanejs/hook-form 0.1.0

package/src/logic/generateId.ts

@@ -0,0 +1,14 @@
+// Vendored from react-hook-form@7.81.0 src/logic/generateId.ts (octane port).
+export default () => {
+	if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+		return crypto.randomUUID();
+	}
+
+	const d = typeof performance === 'undefined' ? Date.now() : performance.now() * 1000;
+
+	return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+		const r = ((Math.random() * 16 + d) % 16) | 0;
+
+		return (c == 'x' ? r : (r & 0x3) | 0x8).toString(16);
+	});
+};

package/src/logic/generateWatchOutput.ts

@@ -0,0 +1,27 @@
+// Vendored from react-hook-form@7.81.0 src/logic/generateWatchOutput.ts (octane port).
+import type { DeepPartial, FieldValues, Names } from '../types';
+import get from '../utils/get';
+import isString from '../utils/isString';
+
+export default <T>(
+	names: string | string[] | undefined,
+	_names: Names,
+	formValues?: FieldValues,
+	isGlobal?: boolean,
+	defaultValue?: DeepPartial<T> | unknown,
+) => {
+	if (isString(names)) {
+		isGlobal && _names.watch.add(names);
+		return get(formValues, names, defaultValue);
+	}
+
+	if (Array.isArray(names)) {
+		return names.map(
+			(fieldName) => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName)),
+		);
+	}
+
+	isGlobal && (_names.watchAll = true);
+
+	return formValues;
+};

package/src/logic/getCheckboxValue.ts

@@ -0,0 +1,36 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getCheckboxValue.ts (octane port).
+import isUndefined from '../utils/isUndefined';
+
+type CheckboxFieldResult = {
+	isValid: boolean;
+	value: string | string[] | boolean | undefined;
+};
+
+const defaultResult: CheckboxFieldResult = {
+	value: false,
+	isValid: false,
+};
+
+const validResult = { value: true, isValid: true };
+
+export default (options?: HTMLInputElement[]): CheckboxFieldResult => {
+	if (Array.isArray(options)) {
+		if (options.length > 1) {
+			const values = options
+				.filter((option) => option && option.checked && !option.disabled)
+				.map((option) => option.value);
+			return { value: values, isValid: !!values.length };
+		}
+
+		return options[0].checked && !options[0].disabled
+			? // @ts-expect-error expected to work in the browser
+				options[0].attributes && !isUndefined(options[0].attributes.value)
+				? isUndefined(options[0].value) || options[0].value === ''
+					? validResult
+					: { value: options[0].value, isValid: true }
+				: validResult
+			: defaultResult;
+	}
+
+	return defaultResult;
+};

package/src/logic/getDirtyFields.ts

@@ -0,0 +1,120 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getDirtyFields.ts (octane port).
+import type { FieldRefs } from '../types';
+import deepEqual from '../utils/deepEqual';
+import get from '../utils/get';
+import isNullOrUndefined from '../utils/isNullOrUndefined';
+import isObject from '../utils/isObject';
+import isPrimitive from '../utils/isPrimitive';
+import isUndefined from '../utils/isUndefined';
+import objectHasFunction from '../utils/objectHasFunction';
+
+function isTraversable<T>(value: T): boolean {
+	return Array.isArray(value) || (isObject(value) && !objectHasFunction(value));
+}
+
+function isRegisteredLeaf(fields: FieldRefs | undefined, path: string): boolean {
+	const field = fields && get(fields, path);
+	return !!(field && '_f' in field);
+}
+
+function markFieldsDirty<T>(
+	data: T,
+	fields: Record<string, any> = {},
+	fieldRefs?: FieldRefs,
+	path = '',
+) {
+	for (const key in data) {
+		const value = data[key];
+		const currentPath = path ? `${path}.${key}` : key;
+
+		if (
+			isTraversable(value) &&
+			(!Array.isArray(value) || !isRegisteredLeaf(fieldRefs, currentPath))
+		) {
+			fields[key] = Array.isArray(value) ? [] : {};
+			markFieldsDirty(value, fields[key], fieldRefs, currentPath);
+		} else if (!isUndefined(value)) {
+			fields[key] = true;
+		}
+	}
+
+	return fields;
+}
+
+function pruneDirtyFields<T>(value: T): T {
+	if (value === false) {
+		return undefined as T;
+	}
+
+	if (value === true) {
+		return true as T;
+	}
+
+	if (Array.isArray(value)) {
+		const result = value.map((value) => pruneDirtyFields(value));
+		return (result.some((value) => value !== undefined) ? result : undefined) as T;
+	}
+
+	if (isObject(value)) {
+		const result: Record<string, unknown> = {};
+
+		for (const key in value) {
+			const pruned = pruneDirtyFields(value[key]);
+
+			if (!isUndefined(pruned)) {
+				result[key] = pruned;
+			}
+		}
+
+		return (Object.keys(result).length ? result : undefined) as T;
+	}
+
+	return undefined as T;
+}
+
+export default function getDirtyFields<T>(
+	data: T,
+	formValues: T,
+	dirtyFieldsFromValues?: Record<
+		Extract<keyof T, string>,
+		ReturnType<typeof markFieldsDirty> | boolean
+	>,
+	fieldRefs?: FieldRefs,
+	path = '',
+) {
+	if (!dirtyFieldsFromValues) {
+		dirtyFieldsFromValues = markFieldsDirty(formValues, {}, fieldRefs);
+	}
+
+	for (const key in data) {
+		const value = data[key];
+		const currentPath = path ? `${path}.${key}` : key;
+
+		if (
+			isTraversable(value) &&
+			(!Array.isArray(value) || !isRegisteredLeaf(fieldRefs, currentPath))
+		) {
+			if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
+				dirtyFieldsFromValues[key] = markFieldsDirty(
+					value,
+					Array.isArray(value) ? [] : {},
+					fieldRefs,
+					currentPath,
+				);
+			} else {
+				getDirtyFields(
+					value,
+					isNullOrUndefined(formValues) ? {} : formValues[key],
+					dirtyFieldsFromValues[key],
+					fieldRefs,
+					currentPath,
+				);
+			}
+		} else {
+			const formValue = formValues[key];
+			dirtyFieldsFromValues[key] = !deepEqual(value, formValue);
+		}
+	}
+
+	return pruneDirtyFields(dirtyFieldsFromValues) || {};
+}

package/src/logic/getEventValue.ts

@@ -0,0 +1,12 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getEventValue.ts (octane port).
+import isCheckBoxInput from '../utils/isCheckBoxInput';
+import isObject from '../utils/isObject';
+
+type Event = { target: any };
+
+export default (event: unknown) =>
+	isObject(event) && (event as Event).target
+		? isCheckBoxInput((event as Event).target)
+			? (event as Event).target.checked
+			: (event as Event).target.value
+		: event;

package/src/logic/getFieldValue.ts

@@ -0,0 +1,33 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getFieldValue.ts (octane port).
+import type { Field } from '../types';
+import isCheckBox from '../utils/isCheckBoxInput';
+import isFileInput from '../utils/isFileInput';
+import isMultipleSelect from '../utils/isMultipleSelect';
+import isRadioInput from '../utils/isRadioInput';
+import isUndefined from '../utils/isUndefined';
+
+import getCheckboxValue from './getCheckboxValue';
+import getFieldValueAs from './getFieldValueAs';
+import getRadioValue from './getRadioValue';
+
+export default function getFieldValue(_f: Field['_f']) {
+	const ref = _f.ref;
+
+	if (isFileInput(ref)) {
+		return ref.files;
+	}
+
+	if (isRadioInput(ref)) {
+		return getRadioValue(_f.refs).value;
+	}
+
+	if (isMultipleSelect(ref)) {
+		return [...ref.selectedOptions].map(({ value }) => value);
+	}
+
+	if (isCheckBox(ref)) {
+		return getCheckboxValue(_f.refs).value;
+	}
+
+	return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
+}

package/src/logic/getFieldValueAs.ts

@@ -0,0 +1,22 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getFieldValueAs.ts (octane port).
+import type { Field, NativeFieldValue } from '../types';
+import isString from '../utils/isString';
+import isUndefined from '../utils/isUndefined';
+
+export default <T extends NativeFieldValue>(
+	value: T,
+	{ valueAsNumber, valueAsDate, setValueAs }: Field['_f'],
+) =>
+	isUndefined(value)
+		? value
+		: valueAsNumber
+			? value === ''
+				? NaN
+				: value
+					? +value
+					: value
+			: valueAsDate && isString(value)
+				? new Date(value)
+				: setValueAs
+					? setValueAs(value)
+					: value;

package/src/logic/getFocusFieldName.ts

@@ -0,0 +1,13 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getFocusFieldName.ts (octane port).
+import type { FieldArrayMethodProps, InternalFieldName } from '../types';
+import isUndefined from '../utils/isUndefined';
+
+export default (
+	name: InternalFieldName,
+	index: number,
+	options: FieldArrayMethodProps = {},
+): string =>
+	options.shouldFocus || isUndefined(options.shouldFocus)
+		? options.focusName ||
+			`${name}.${isUndefined(options.focusIndex) ? index : options.focusIndex}.`
+		: '';

package/src/logic/getNodeParentName.ts

@@ -0,0 +1,4 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getNodeParentName.ts (octane port).
+const ARRAY_INDEX_RE = /\.\d+(\.|$)/;
+
+export default (name: string) => name.substring(0, name.search(ARRAY_INDEX_RE)) || name;

package/src/logic/getProxyFormState.ts

@@ -0,0 +1,33 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getProxyFormState.ts (octane port).
+import { VALIDATION_MODE } from '../constants';
+import type { Control, FieldValues, FormState, ReadFormState } from '../types';
+
+export default <
+	TFieldValues extends FieldValues,
+	TContext = any,
+	TTransformedValues = TFieldValues,
+>(
+	formState: FormState<TFieldValues>,
+	control: Control<TFieldValues, TContext, TTransformedValues>,
+	localProxyFormState?: ReadFormState,
+	isRoot = true,
+) => {
+	const result = {} as typeof formState;
+
+	for (const key in formState) {
+		Object.defineProperty(result, key, {
+			get: () => {
+				const _key = key as keyof FormState<TFieldValues> & keyof ReadFormState;
+
+				if (control._proxyFormState[_key] !== VALIDATION_MODE.all) {
+					control._proxyFormState[_key] = !isRoot || VALIDATION_MODE.all;
+				}
+
+				localProxyFormState && (localProxyFormState[_key] = true);
+				return formState[_key];
+			},
+		});
+	}
+
+	return result;
+};

package/src/logic/getRadioValue.ts

@@ -0,0 +1,24 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getRadioValue.ts (octane port).
+type RadioFieldResult = {
+	isValid: boolean;
+	value: number | string | null;
+};
+
+const defaultReturn: RadioFieldResult = {
+	isValid: false,
+	value: null,
+};
+
+export default (options?: HTMLInputElement[]): RadioFieldResult =>
+	Array.isArray(options)
+		? options.reduce(
+				(previous, option): RadioFieldResult =>
+					option && option.checked && !option.disabled
+						? {
+								isValid: true,
+								value: option.value,
+							}
+						: previous,
+				defaultReturn,
+			)
+		: defaultReturn;

package/src/logic/getResolverOptions.ts

@@ -0,0 +1,33 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getResolverOptions.ts (octane port).
+import type {
+	CriteriaMode,
+	Field,
+	FieldName,
+	FieldRefs,
+	FieldValues,
+	InternalFieldName,
+} from '../types';
+import { get } from '../utils';
+import set from '../utils/set';
+
+export default <TFieldValues extends FieldValues>(
+	fieldsNames: Set<InternalFieldName> | InternalFieldName[],
+	_fields: FieldRefs,
+	criteriaMode?: CriteriaMode,
+	shouldUseNativeValidation?: boolean | undefined,
+) => {
+	const fields: Record<InternalFieldName, Field['_f']> = {};
+
+	for (const name of fieldsNames) {
+		const field: Field = get(_fields, name);
+
+		field && set(fields, name, field._f);
+	}
+
+	return {
+		criteriaMode,
+		names: [...fieldsNames] as FieldName<TFieldValues>[],
+		fields,
+		shouldUseNativeValidation,
+	};
+};

package/src/logic/getRuleValue.ts

@@ -0,0 +1,16 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getRuleValue.ts (octane port).
+import type { ValidationRule, ValidationValue, ValidationValueMessage } from '../types';
+import isObject from '../utils/isObject';
+import isRegex from '../utils/isRegex';
+import isUndefined from '../utils/isUndefined';
+
+export default <T extends ValidationValue>(rule?: ValidationRule<T> | ValidationValueMessage<T>) =>
+	isUndefined(rule)
+		? rule
+		: isRegex(rule)
+			? rule.source
+			: isObject(rule)
+				? isRegex(rule.value)
+					? rule.value.source
+					: rule.value
+				: rule;

package/src/logic/getValidateError.ts

@@ -0,0 +1,22 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getValidateError.ts (octane port).
+import type { FieldError, Ref, ValidateResult } from '../types';
+import isBoolean from '../utils/isBoolean';
+import isString from '../utils/isString';
+
+export default function getValidateError(
+	result: ValidateResult,
+	ref: Ref,
+	type = 'validate',
+): FieldError | void {
+	if (
+		isString(result) ||
+		(Array.isArray(result) && result.every(isString)) ||
+		(isBoolean(result) && !result)
+	) {
+		return {
+			type,
+			message: isString(result) ? result : '',
+			ref,
+		};
+	}
+}

package/src/logic/getValidationModes.ts

@@ -0,0 +1,11 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getValidationModes.ts (octane port).
+import { VALIDATION_MODE } from '../constants';
+import type { Mode, ValidationModeFlags } from '../types';
+
+export default (mode?: Mode): ValidationModeFlags => ({
+	isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
+	isOnBlur: mode === VALIDATION_MODE.onBlur,
+	isOnChange: mode === VALIDATION_MODE.onChange,
+	isOnAll: mode === VALIDATION_MODE.all,
+	isOnTouch: mode === VALIDATION_MODE.onTouched,
+});

package/src/logic/getValueAndMessage.ts

@@ -0,0 +1,12 @@
+// Vendored from react-hook-form@7.81.0 src/logic/getValueAndMessage.ts (octane port).
+import type { ValidationRule } from '../types';
+import isObject from '../utils/isObject';
+import isRegex from '../utils/isRegex';
+
+export default (validationData?: ValidationRule) =>
+	isObject(validationData) && !isRegex(validationData)
+		? validationData
+		: {
+				value: validationData,
+				message: '',
+			};

package/src/logic/hasPromiseValidation.ts

@@ -0,0 +1,27 @@
+// Vendored from react-hook-form@7.81.0 src/logic/hasPromiseValidation.ts (octane port).
+import type { Field, Validate } from '../types';
+import isFunction from '../utils/isFunction';
+import isObject from '../utils/isObject';
+
+const ASYNC_FUNCTION = 'AsyncFunction';
+
+export default (fieldReference: Field['_f']) => {
+	if (!fieldReference || !fieldReference.validate) return false;
+
+	if (isFunction(fieldReference.validate)) {
+		return fieldReference.validate.constructor.name === ASYNC_FUNCTION;
+	}
+
+	if (isObject(fieldReference.validate)) {
+		for (const key in fieldReference.validate) {
+			if (
+				(fieldReference.validate[key] as Validate<unknown, unknown>).constructor.name ===
+				ASYNC_FUNCTION
+			) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+};

package/src/logic/hasValidation.ts

@@ -0,0 +1,12 @@
+// Vendored from react-hook-form@7.81.0 src/logic/hasValidation.ts (octane port).
+import type { Field } from '../types';
+
+export default (options: Field['_f']) =>
+	options.mount &&
+	(options.required ||
+		options.min ||
+		options.max ||
+		options.maxLength ||
+		options.minLength ||
+		options.pattern ||
+		options.validate);

package/src/logic/index.ts

@@ -0,0 +1,3 @@
+// Vendored from react-hook-form@7.81.0 src/logic/index.ts (octane port).
+export { default as appendErrors } from './appendErrors';
+export { createFormControl } from './createFormControl';

package/src/logic/isNameInFieldArray.ts

@@ -0,0 +1,7 @@
+// Vendored from react-hook-form@7.81.0 src/logic/isNameInFieldArray.ts (octane port).
+import type { InternalFieldName } from '../types';
+
+export default (names: Set<InternalFieldName>, name: InternalFieldName) =>
+	name
+		.split('.')
+		.some((part, index, arr) => !isNaN(Number(part)) && names.has(arr.slice(0, index).join('.')));

package/src/logic/isWatched.ts

@@ -0,0 +1,11 @@
+// Vendored from react-hook-form@7.81.0 src/logic/isWatched.ts (octane port).
+import type { InternalFieldName, Names } from '../types';
+
+export default (name: InternalFieldName, _names: Names, isBlurEvent?: boolean) => {
+	if (isBlurEvent) return false;
+	if (_names.watchAll || _names.watch.has(name)) return true;
+	for (const watchName of _names.watch) {
+		if (name.startsWith(watchName) && name.charAt(watchName.length) === '.') return true;
+	}
+	return false;
+};

package/src/logic/iterateFieldsByAction.ts

@@ -0,0 +1,37 @@
+// Vendored from react-hook-form@7.81.0 src/logic/iterateFieldsByAction.ts (octane port).
+import type { FieldRefs, InternalFieldName, Ref } from '../types';
+import { get } from '../utils';
+import isObject from '../utils/isObject';
+
+const iterateFieldsByAction = (
+	fields: FieldRefs,
+	action: (ref: Ref, name: string) => 1 | undefined | void,
+	fieldsNames?: Set<InternalFieldName> | InternalFieldName[] | 0,
+	abortEarly?: boolean,
+) => {
+	for (const key of fieldsNames || Object.keys(fields)) {
+		const field = get(fields, key);
+
+		if (field) {
+			const { _f, ...currentField } = field;
+
+			if (_f) {
+				if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
+					return true;
+				} else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
+					return true;
+				} else {
+					if (iterateFieldsByAction(currentField, action)) {
+						break;
+					}
+				}
+			} else if (isObject(currentField)) {
+				if (iterateFieldsByAction(currentField as FieldRefs, action)) {
+					break;
+				}
+			}
+		}
+	}
+	return;
+};
+export default iterateFieldsByAction;

package/src/logic/schemaErrorLookup.ts

@@ -0,0 +1,54 @@
+// Vendored from react-hook-form@7.81.0 src/logic/schemaErrorLookup.ts (octane port).
+import type { FieldError, FieldErrors, FieldValues } from '../types';
+import get from '../utils/get';
+import isKey from '../utils/isKey';
+
+export default function schemaErrorLookup<T extends FieldValues = FieldValues>(
+	errors: FieldErrors<T>,
+	_fields: FieldValues,
+	name: string,
+): {
+	error?: FieldError;
+	name: string;
+} {
+	const error = get(errors, name);
+
+	if (error || isKey(name)) {
+		return {
+			error,
+			name,
+		};
+	}
+
+	const names = name.split('.');
+
+	while (names.length) {
+		const fieldName = names.join('.');
+		const field = get(_fields, fieldName);
+		const foundError = get(errors, fieldName);
+
+		if (field && !Array.isArray(field) && name !== fieldName) {
+			return { name };
+		}
+
+		if (foundError && foundError.type) {
+			return {
+				name: fieldName,
+				error: foundError,
+			};
+		}
+
+		if (foundError && foundError.root && foundError.root.type) {
+			return {
+				name: `${fieldName}.root`,
+				error: foundError.root,
+			};
+		}
+
+		names.pop();
+	}
+
+	return {
+		name,
+	};
+}

package/src/logic/shouldRenderFormState.ts

@@ -0,0 +1,25 @@
+// Vendored from react-hook-form@7.81.0 src/logic/shouldRenderFormState.ts (octane port).
+import { VALIDATION_MODE } from '../constants';
+import type { FieldValues, FormState, InternalFieldName, ReadFormState } from '../types';
+
+export default <T extends FieldValues, K extends ReadFormState>(
+	formStateData: Partial<FormState<T>> & {
+		name?: InternalFieldName;
+		values?: T;
+	},
+	_proxyFormState: K,
+	updateFormState: (formState: Partial<FormState<T>>) => void,
+	isRoot?: boolean,
+) => {
+	updateFormState(formStateData);
+	const { name, ...formState } = formStateData;
+	const keys = Object.keys(formState);
+
+	return (
+		!keys.length ||
+		(isRoot && keys.length >= Object.keys(_proxyFormState).length) ||
+		keys.find(
+			(key) => _proxyFormState[key as keyof ReadFormState] === (!isRoot || VALIDATION_MODE.all),
+		)
+	);
+};

package/src/logic/shouldSubscribeByName.ts

@@ -0,0 +1,18 @@
+// Vendored from react-hook-form@7.81.0 src/logic/shouldSubscribeByName.ts (octane port).
+import convertToArrayPayload from '../utils/convertToArrayPayload';
+
+export default <T extends string | readonly string[] | undefined>(
+	name?: T,
+	signalName?: string,
+	exact?: boolean,
+) =>
+	!name ||
+	!signalName ||
+	name === signalName ||
+	convertToArrayPayload(name).some(
+		(currentName) =>
+			currentName &&
+			(exact
+				? currentName === signalName || currentName.startsWith(signalName + '.')
+				: currentName.startsWith(signalName) || signalName.startsWith(currentName)),
+	);