trackedFunction is not composable with the use within a resource.

[NullVoxPopuli]

For example, this should be possible:

/**
 * A subset of the state provided by `trackedFunction`
 */
interface NormalizedState<Data> {
	value: Data | undefined;

	error: unknown;
	isError: boolean;

	isResolved: boolean;
	isPending: boolean;
	isRejected: boolean;
	isSettled: boolean;

	isLoading: boolean;
	isFinished: boolean;
}

class SimpleState<Data> implements NormalizedState<Data> {
	constructor(public value: Data) {}
	get isError() {
		return false;
	}
	get isResolved() {
		return true;
	}
	get isPending() {
		return false;
	}
	get isLoading() {
		return false;
	}
	get isRejected() {
		return false;
	}
	get isSettled() {
		return true;
	}
	get isFinished() {
		return true;
	}

	get error() {
		return null;
	}
}

function normalizedData<Data>(data: Promise<Data>): NormalizedState<Data>;
function normalizedData<Data>(data: () => Promise<Data>): NormalizedState<Data>;
function normalizedData<Data>(data: () => Data): NormalizedState<Data>;
function normalizedData<Data>(data: Data): NormalizedState<Data>;
function normalizedData<Data>(
	data: Data | (() => Data) | (() => Promise<Data>) | Promise<Data>,
): NormalizedState<Data> {
	/**
	 * This resource, itself, does not have any cleanup,
	 * but the underlying resources `use`d within do.
	 */
	return resource(({ use }) => {
		if (typeof data === 'function') {
			const state = use(trackedFunction(data));

			return () => state.current;
		}

		if (typeof data === 'object' && data !== null) {
			if ('then' in data) {
				const state = use(trackedFunction(async () => data));

				return () => state.current;
			}
		}

		return new SimpleState<Data>(data);
	});
}

export const NormalizedData = resourceFactory(normalizedData) as typeof normalizedData;

[NullVoxPopuli]

Implemented in #975