"use client";
import { useEffect, useRef, useState } from "react";
import { useDrag } from "@use-gesture/react";
import { useReplicache } from "src/replicache";
import { useSubscribe } from "src/replicache/useSubscribe";
import { scanIndex } from "src/replicache/utils";
import type { Data } from "src/replicache/attributes";
import { localImages } from "src/utils/addImage";
import {
COVER_ASPECT,
renderCoverCrop,
saveCoverImageCrop,
type CoverCrop,
} from "src/utils/cropCoverImage";
import { Modal } from "components/Modal";
import { ButtonPrimary } from "components/Buttons";
import { DotLoader } from "components/utils/DotLoader";
export function CoverImageCropModal(props: {
coverEntity: string | null;
open: boolean;
onOpenChange: (open: boolean) => void;
}) {
return (
{props.coverEntity && (
props.onOpenChange(false)}
/>
)}
);
}
function CoverImageCropper(props: { coverEntity: string; onDone: () => void }) {
let { rep } = useReplicache();
let cover = useSubscribe(
rep,
async (tx) => {
if (!(await tx.get("initialized"))) return null;
let scan = scanIndex(tx);
let [image] = await scan.eav(props.coverEntity, "block/image");
let [original] = await scan.eav(
props.coverEntity,
"cover-image/original",
);
let [crop] = await scan.eav(props.coverEntity, "cover-image/crop");
return {
image: image?.data ?? null,
original: original?.data ?? null,
crop: crop?.data.value ?? null,
};
},
{ dependencies: [props.coverEntity] },
);
let source = cover?.original ?? cover?.image;
let loaded = useLoadedImage(source?.src);
return (
{loaded.state === "loaded" &&
loaded.src === source?.src &&
cover?.image ? (
) : (
{loaded.state === "error" ? (
"Couldn't load this image"
) : (
)}
)}
);
}
const MIN_CROP = 0.15;
const KEYBOARD_MOVE = 0.02;
const KEYBOARD_SCALE = 1.1;
type Edge = "left" | "right";
const EDGE_DIRS: Record = { left: -1, right: 1 };
function CropEditor(props: {
coverEntity: string;
bitmap: ImageBitmap;
url: string;
source: Data<"block/image">;
savedCrop: CoverCrop | null;
uploading: boolean;
onDone: () => void;
}) {
let { rep } = useReplicache();
let imageAspect = props.bitmap.width / props.bitmap.height;
let [crop, setCrop] = useState(() =>
clampCrop(
props.savedCrop ?? centeredCrop(maxCropWidth(imageAspect), imageAspect),
imageAspect,
),
);
let [saving, setSaving] = useState(false);
let [error, setError] = useState(null);
let imageRef = useRef(null);
let move = (dx: number, dy: number) =>
setCrop((c) => clampCrop({ ...c, x: c.x + dx, y: c.y + dy }, imageAspect));
let scale = (factor: number) =>
setCrop((c) =>
clampCrop(
centeredCrop(c.width * factor, imageAspect, [
c.x + c.width / 2,
c.y + c.height / 2,
]),
imageAspect,
),
);
let bindMove = useDrag(({ delta: [dx, dy] }) => {
let rect = imageRef.current?.getBoundingClientRect();
if (!rect?.width) return;
move(dx / rect.width, dy / rect.height);
});
let bindResize = useDrag(({ xy: [px], args: [edge], first, memo }) => {
let rect = imageRef.current?.getBoundingClientRect();
if (!rect?.width) return memo;
let dir = EDGE_DIRS[edge as Edge];
let anchor: [number, number] =
first || !memo
? [dir > 0 ? crop.x : crop.x + crop.width, crop.y + crop.height / 2]
: memo;
setCrop(
resizeFrom(anchor, dir, (px - rect.left) / rect.width, imageAspect),
);
return anchor;
});
let cropStyle = {
left: `${crop.x * 100}%`,
top: `${crop.y * 100}%`,
width: `${crop.width * 100}%`,
height: `${crop.height * 100}%`,
};
let save = async () => {
if (!rep) return;
setSaving(true);
setError(null);
try {
let file = await renderCoverCrop(props.bitmap, crop);
await saveCoverImageCrop(rep, {
coverEntity: props.coverEntity,
original: props.source,
crop,
file,
});
props.onDone();
} catch (e) {
console.error(e);
setError("Couldn't crop this image. Please try again!");
setSaving(false);
}
};
return (
<>
{props.uploading
? "Finishing upload…"
: error ?? "Drag and resize to edit the crop."}
{saving ? : "Save"}
{
let moves: Record
= {
ArrowLeft: [-KEYBOARD_MOVE, 0],
ArrowRight: [KEYBOARD_MOVE, 0],
ArrowUp: [0, -KEYBOARD_MOVE],
ArrowDown: [0, KEYBOARD_MOVE],
};
if (moves[e.key]) move(...moves[e.key]);
else if (e.key === "+" || e.key === "=") scale(KEYBOARD_SCALE);
else if (e.key === "-") scale(1 / KEYBOARD_SCALE);
else return;
e.preventDefault();
}}
>
{(Object.keys(EDGE_DIRS) as Edge[]).map((edge) => (
0 ? crop.width : 0)) * 100}%`,
top: `${(crop.y + crop.height / 2) * 100}%`,
}}
/>
))}
>
);
}
function useLoadedImage(src: string | undefined) {
let [state, setState] = useState<
| { state: "loading" }
| { state: "error" }
| { state: "loaded"; src: string; bitmap: ImageBitmap; url: string }
>({ state: "loading" });
useEffect(() => {
if (!src) return;
let cancelled = false;
let bitmap: ImageBitmap | undefined;
let url: string | undefined;
setState({ state: "loading" });
(async () => {
try {
let response = await fetch(localImages.get(src) ?? src);
if (!response.ok) throw new Error(`Image fetch ${response.status}`);
let blob = await response.blob();
bitmap = await createImageBitmap(blob);
url = URL.createObjectURL(blob);
if (cancelled) return cleanup();
setState({ state: "loaded", src, bitmap, url });
} catch (e) {
console.error(e);
if (!cancelled) setState({ state: "error" });
}
})();
function cleanup() {
bitmap?.close();
if (url) URL.revokeObjectURL(url);
}
return () => {
cancelled = true;
cleanup();
};
}, [src]);
return state;
}
const clamp = (n: number, min: number, max: number) =>
Math.min(max, Math.max(min, n));
const widthPerHeight = (imageAspect: number) => COVER_ASPECT / imageAspect;
const maxCropWidth = (imageAspect: number) =>
Math.min(1, widthPerHeight(imageAspect));
function centeredCrop(
width: number,
imageAspect: number,
[cx, cy]: [number, number] = [0.5, 0.5],
): CoverCrop {
let height = width / widthPerHeight(imageAspect);
return { x: cx - width / 2, y: cy - height / 2, width, height };
}
function clampCrop(crop: CoverCrop, imageAspect: number): CoverCrop {
let max = maxCropWidth(imageAspect);
let width = clamp(crop.width, max * MIN_CROP, max);
let height = width / widthPerHeight(imageAspect);
return {
x: clamp(crop.x, 0, 1 - width),
y: clamp(crop.y, 0, 1 - height),
width,
height,
};
}
function resizeFrom(
[ax, cy]: [number, number],
dir: number,
px: number,
imageAspect: number,
): CoverCrop {
let max = maxCropWidth(imageAspect);
let width = clamp(
dir * (px - ax),
max * MIN_CROP,
Math.min(max, dir > 0 ? 1 - ax : ax),
);
let height = width / widthPerHeight(imageAspect);
return {
x: dir > 0 ? ax : ax - width,
y: clamp(cy - height / 2, 0, 1 - height),
width,
height,
};
}