Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

2.7 KB
Raw Blame
import * as Data from "effect/Data";
import { hasTag } from "~/lib/taggedUnion";
import { useAtomValue } from "@effect/atom-react";
import { resolveAssetUrl } from "@akeru/client-runtime/state/assets";
import type { AssetImageDimensions, AssetResource, EnvironmentId } from "@akeru/contracts";
import { AsyncResult } from "effect/unstable/reactivity";
import { useMemo } from "react";

import { assetEnvironment } from "~/state/assets";
import { usePreparedConnection } from "~/state/session";

export { resolveAssetUrl } from "@akeru/client-runtime/state/assets";

export type AssetUrlState =
  | { readonly _tag: "Loading" }
  | { readonly _tag: "Failure" }
  | {
      readonly _tag: "Success";
      readonly url: string;
      readonly sourcePath?: string;
      readonly imageDimensions?: AssetImageDimensions;
    };

const AssetUrlState = Data.taggedEnum<AssetUrlState>();

export function useAssetUrlState(
  environmentId: EnvironmentId,
  resource: AssetResource,
): AssetUrlState {
  const preparedConnection = usePreparedConnection(environmentId);

  const result = useAtomValue(
    assetEnvironment.createUrl({
      environmentId,
      input: { resource },
    }),
  );

  if (hasTag(result, "Failure")) {
    return AssetUrlState.Failure();
  }

  if (hasTag(preparedConnection, "None") || !hasTag(result, "Success")) {
    return AssetUrlState.Loading();
  }

  const url = resolveAssetUrl(preparedConnection.value.httpBaseUrl, result.value.relativeUrl);

  return url === null
    ? AssetUrlState.Failure()
    : AssetUrlState.Success({
        url,
        ...(result.value.sourcePath !== undefined ? { sourcePath: result.value.sourcePath } : {}),
        ...(result.value.imageDimensions !== undefined
          ? { imageDimensions: result.value.imageDimensions }
          : {}),
      });
}

export function useAssetUrl(environmentId: EnvironmentId, resource: AssetResource): string | null {
  const result = useAssetUrlState(environmentId, resource);

  if (!hasTag(result, "Success")) {
    return null;
  }

  return result.url;
}

export function useAssetUrls(
  environmentId: EnvironmentId,
  resources: ReadonlyArray<AssetResource>,
): ReadonlyArray<string | null> {
  const preparedConnection = usePreparedConnection(environmentId);

  const results = useAtomValue(
    assetEnvironment.createUrls({
      environmentId,
      resources,
    }),
  );

  return useMemo(
    () =>
      hasTag(preparedConnection, "None")
        ? resources.map(() => null)
        : results.map((result) =>
            AsyncResult.isSuccess(result)
              ? resolveAssetUrl(preparedConnection.value.httpBaseUrl, result.value.relativeUrl)
              : null,
          ),
    [preparedConnection, resources, results],
  );
}