import { useAtomValue } from "@effect/atom-react";
import {
type AssetUrlState as RuntimeAssetUrlState,
assetUrlStateFromResult,
blockedAssetUrlState,
EMPTY_ASSET_URL_ATOM,
makeRevisionedAssetUrlFamily,
resolveAssetUrl,
} from "@t3tools/client-runtime/state/assets";
import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
import { AssetResource, EnvironmentId } from "@t3tools/contracts";
import { AsyncResult } from "effect/reactivity";
import { assetEnvironment } from "~/state/assets";
import { useFilesystemReadAccess } from "~/state/filesystem";
import { usePreparedConnection } from "~/state/session";
import { useAtomQueryRunner } from "~/state/use-atom-query-runner";
export { resolveAssetUrl } from "@t3tools/client-runtime/state/assets";
export type AssetUrlState = RuntimeAssetUrlState & { readonly waiting?: boolean };
const revisionedAssetUrl = makeRevisionedAssetUrlFamily(assetEnvironment.createUrl);
/**
* Pass `revision` for a workspace file whose bytes can change under the same
* path; each new revision gets a freshly minted URL.
*/
export function useAssetUrlState(
environmentId: EnvironmentId | null,
resource: AssetResource | null,
revision?: string | null,
): AssetUrlState {
const blocked = blockedAssetUrlState(resource, useFilesystemReadAccess(environmentId));
const preparedConnection = usePreparedConnection(environmentId);
const result = useAtomValue(
blocked !== null || environmentId === null || resource === null
? EMPTY_ASSET_URL_ATOM
: revision === undefined
? assetEnvironment.createUrl({ environmentId, input: { resource } })
: revisionedAssetUrl({ environmentId, input: { resource }, revision }),
);
if (blocked !== null) return blocked;
return {
...assetUrlStateFromResult(
result,
preparedConnection._tag === "Some" ? preparedConnection.value.httpBaseUrl : null,
),
...(result.waiting ? { waiting: true } : {}),
};
}
export function useAssetUrlRefresh(
environmentId: EnvironmentId | null,
resource: AssetResource | null,
): () => Promise<string | null> {
const connection = usePreparedConnection(environmentId);
const httpBaseUrl = connection._tag === "Some" ? connection.value.httpBaseUrl : null;
const refresh = useAtomQueryRunner(assetEnvironment.createUrl, {
reportFailure: false,
refresh: true,
});
return async () => {
if (environmentId === null || resource === null || httpBaseUrl === null) return null;
const result = await refresh({ environmentId, input: { resource } });
if (result._tag === "Failure") throw squashAtomCommandFailure(result);
return resolveAssetUrl(httpBaseUrl, result.value.relativeUrl);
};
}
export function useAssetUrls(
environmentId: EnvironmentId,
resources: ReadonlyArray<AssetResource>,
): ReadonlyArray<string | null> {
const preparedConnection = usePreparedConnection(environmentId);
const { canReadFiles } = useFilesystemReadAccess(environmentId);
const allowedResources = canReadFiles
? resources
: resources.filter((resource) => !isFileResource(resource));
const results = useAtomValue(
assetEnvironment.createUrls({
environmentId,
resources: allowedResources,
}),
);
if (preparedConnection._tag === "None") return resources.map(() => null);
const urls: Array<string | null> = [];
let resultIndex = 0;
for (const resource of resources) {
if (!canReadFiles && isFileResource(resource)) {
urls.push(null);
continue;
}
const result = results[resultIndex];
resultIndex += 1;
urls.push(
result && AsyncResult.isSuccess(result)
? resolveAssetUrl(preparedConnection.value.httpBaseUrl, result.value.relativeUrl)
: null,
);
}
return urls;
}
function isFileResource(resource: AssetResource): boolean {
return (
resource._tag === "workspace-file" ||
resource._tag === "media-file" ||
resource._tag === "draft-workspace-file"
);
}