@manta-eu/react 0.1.0

package/dist/lib/test-utils.js

@@ -0,0 +1,16 @@
+import { v7 as uuidv7 } from "uuid";
+export function createMockUser(overrides) {
+    return {
+        id: uuidv7(),
+        email: "test@example.com",
+        name: "Test User",
+        ...overrides,
+    };
+}
+export function createMockDatastore(overrides) {
+    return {
+        id: uuidv7(),
+        name: "Test Datastore",
+        ...overrides,
+    };
+}

package/dist/lib/think-compaction.d.ts

@@ -0,0 +1,3 @@
+import type { ChatUIMessage } from "@manta-eu/client/shared/index";
+export declare function isThinkCompactionMessage(message: ChatUIMessage): boolean;
+//# sourceMappingURL=think-compaction.d.ts.map

package/dist/lib/think-compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"think-compaction.d.ts","sourceRoot":"","sources":["../../src/lib/think-compaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAMnE,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAExE"}

package/dist/lib/think-compaction.js

@@ -0,0 +1,7 @@
+import { isCompactionMessage } from "agents/experimental/memory/utils";
+// Think currently uses the same compacted history projection for model context
+// and the client transcript. Track first-class separation in:
+// https://github.com/cloudflare/agents/issues/1676
+export function isThinkCompactionMessage(message) {
+    return isCompactionMessage(message);
+}

package/dist/lib/tool-icons.d.ts

@@ -0,0 +1,11 @@
+import { type ToolName } from "@manta-eu/client/shared/tools";
+import type { ToolUIPart } from "ai";
+import { type LucideIcon } from "lucide-react";
+export declare function getToolIcon(toolName: ToolName): LucideIcon;
+export declare function getSkillToolIcon(part: ToolUIPart): LucideIcon | undefined;
+export declare function getPartIcon(partType: string): LucideIcon;
+export declare function getStatusIcon(status: "complete" | "active" | "pending" | "error"): LucideIcon;
+export declare function mapPartStateToStatus(state?: string): "complete" | "active" | "pending";
+export declare function getStepIconName(text: string): string;
+export declare function getStepIcon(text: ToolName | string): LucideIcon;
+//# sourceMappingURL=tool-icons.d.ts.map

package/dist/lib/tool-icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-icons.d.ts","sourceRoot":"","sources":["../../src/lib/tool-icons.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AACrC,OAAO,EAeL,KAAK,UAAU,EAShB,MAAM,cAAc,CAAC;AA2DtB,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,UAAU,CAE1D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAEzE;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAYxD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,CAK7F;AAED,wBAAgB,oBAAoB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAKtF;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAuDpD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,UAAU,CAG/D"}

package/dist/lib/tool-icons.js

@@ -0,0 +1,90 @@
+import { getSkillToolLabel } from "@manta-eu/client/shared/tools";
+import { AlertTriangle, BarChart3, BookOpen, Brain, Building2, CheckCircle2, Circle, Clock, Database, DollarSign, GitBranch, Images, Lightbulb, Link, Megaphone, Network, Package, Paperclip, Pause, Target, TrendingUp, Zap, } from "lucide-react";
+import { match } from "ts-pattern";
+const toolIconMap = {
+    getRDFoxFacts: Database,
+    addRDFoxFacts: Database,
+    manageRDFoxFacts: Database,
+    getRDFoxRules: Brain,
+    explainRDFoxRules: Brain,
+    manageRDFoxRules: Brain,
+    generateChart: TrendingUp,
+    scheduleTask: Clock,
+    listScheduledTasks: Clock,
+    cancelSchedule: Clock,
+    executeActionPlan: Zap,
+    actionPlanShowcase: Zap,
+    showEntities: Images,
+    enableAutoPilot: Zap,
+    enableAutoPilotCron: Zap,
+    disableAutoPilot: Pause,
+    checkAutoPilotStatus: Zap,
+    setAutoPilotCadence: Clock,
+    markAsLowRisk: CheckCircle2,
+    readUploadedFile: Paperclip,
+};
+const stepIconMap = {
+    ChartLine: TrendingUp,
+    Megaphone: Megaphone,
+    GitBranch: GitBranch,
+    Images: Images,
+    CurrencyDollar: DollarSign,
+    Link: Link,
+    TreeStructure: Network,
+    ChartBar: BarChart3,
+    Books: BookOpen,
+    Target: Target,
+    CheckCircle: CheckCircle2,
+    Package: Package,
+    Buildings: Building2,
+    Database: Database,
+};
+export function getToolIcon(toolName) {
+    return toolIconMap[toolName] ?? Circle;
+}
+export function getSkillToolIcon(part) {
+    return getSkillToolLabel(part) !== undefined ? BookOpen : undefined;
+}
+export function getPartIcon(partType) {
+    return match(partType)
+        .with("reasoning", () => Brain)
+        .with("text", () => Lightbulb)
+        .when((s) => s.startsWith("tool-"), () => {
+        const toolName = partType.replace("tool-", "");
+        return getToolIcon(toolName);
+    })
+        .otherwise(() => Circle);
+}
+export function getStatusIcon(status) {
+    return match(status)
+        .with("complete", () => CheckCircle2)
+        .with("error", () => AlertTriangle)
+        .otherwise(() => Circle);
+}
+export function mapPartStateToStatus(state) {
+    return match(state)
+        .with("done", "output-available", () => "complete")
+        .with("streaming", "input-streaming", () => "active")
+        .otherwise(() => "pending");
+}
+export function getStepIconName(text) {
+    return match(text.toLowerCase())
+        .when((s) => /analyz|growth|boost|plan/.test(s), () => "ChartLine")
+        .when((s) => /campaign|ad account|meta/.test(s), () => "Megaphone")
+        .when((s) => /variant|branch/.test(s), () => "GitBranch")
+        .when((s) => /asset|image/.test(s), () => "Images")
+        .when((s) => /pric|cost|dollar/.test(s), () => "CurrencyDollar")
+        .when((s) => /url|link/.test(s), () => "Link")
+        .when((s) => /structure|entity|explore/.test(s), () => "TreeStructure")
+        .when((s) => /benchmark|performance|kpi/.test(s), () => "ChartBar")
+        .when((s) => /catalog|category/.test(s), () => "Books")
+        .when((s) => /target/.test(s), () => "Target")
+        .when((s) => /status|check/.test(s), () => "CheckCircle")
+        .when((s) => /product/.test(s), () => "Package")
+        .when((s) => /company/.test(s), () => "Buildings")
+        .otherwise(() => "Database");
+}
+export function getStepIcon(text) {
+    const iconName = getStepIconName(text);
+    return stepIconMap[iconName] ?? Database;
+}

package/dist/lib/tool-names.d.ts

@@ -0,0 +1,2 @@
+export declare function formatToolName(toolType: string): string;
+//# sourceMappingURL=tool-names.d.ts.map

package/dist/lib/tool-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/lib/tool-names.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQvD"}

package/dist/lib/tool-names.js

@@ -0,0 +1,9 @@
+export function formatToolName(toolType) {
+    const name = toolType.replace("tool-", "");
+    return name
+        .replace(/RDFox/gi, "")
+        .replace(/([A-Z])/g, " $1")
+        .replace(/^./, (str) => str.toUpperCase())
+        .replace(/\s+/g, " ")
+        .trim();
+}

package/dist/lib/update-notice.d.ts

@@ -0,0 +1,5 @@
+export declare function isStaleChunkError(error: unknown): boolean;
+export type Channel = "none" | "toast" | "screen";
+export declare function announceUpdate(channel: Exclude<Channel, "none">): void;
+export declare function installUpdateNotice(): void;
+//# sourceMappingURL=update-notice.d.ts.map

package/dist/lib/update-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-notice.d.ts","sourceRoot":"","sources":["../../src/lib/update-notice.ts"],"names":[],"mappings":"AAWA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,WAK/C;AAID,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAIlD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,QAoB/D;AAED,wBAAgB,mBAAmB,SAIlC"}

package/dist/lib/update-notice.js

@@ -0,0 +1,39 @@
+import { toast } from "sonner";
+const staleChunkMessages = [
+    "failed to fetch dynamically imported module",
+    "error loading dynamically imported module",
+    "importing a module script failed",
+    "failed to load module script",
+    "expected a javascript module script",
+    "unable to preload css",
+];
+export function isStaleChunkError(error) {
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+    const normalized = message.toLowerCase();
+    return staleChunkMessages.some((candidate) => normalized.includes(candidate));
+}
+const noticeId = "update-notice";
+let shown = "none";
+export function announceUpdate(channel) {
+    if (channel === "screen") {
+        if (shown === "toast")
+            toast.dismiss(noticeId);
+        shown = "screen";
+        return;
+    }
+    if (shown !== "none")
+        return;
+    shown = "toast";
+    toast("A new version of Manta is available", {
+        id: noticeId,
+        description: "Parts of the app can't load until you reload the page.",
+        duration: Number.POSITIVE_INFINITY,
+        style: { pointerEvents: "auto" },
+        action: { label: "Reload", onClick: () => window.location.reload() },
+    });
+}
+export function installUpdateNotice() {
+    window.addEventListener("vite:preloadError", () => {
+        announceUpdate("toast");
+    });
+}

package/dist/lib/upload-client.d.ts

@@ -0,0 +1,15 @@
+import type { GQLAbortUploadMutation, GQLAbortUploadMutationVariables, GQLCompleteUploadMutation, GQLCompleteUploadMutationVariables, GQLInitiateUploadMutation, GQLInitiateUploadMutationVariables } from "@manta-eu/client";
+import type { FileFacts, UploadedFileReference } from "@manta-eu/client/shared/upload";
+export declare function computeFacts(file: File): Promise<FileFacts>;
+export type InitiateUploadMutateAsync = (variables: GQLInitiateUploadMutationVariables) => Promise<GQLInitiateUploadMutation>;
+export type CompleteUploadMutateAsync = (variables: GQLCompleteUploadMutationVariables) => Promise<GQLCompleteUploadMutation>;
+export type AbortUploadMutateAsync = (variables: GQLAbortUploadMutationVariables) => Promise<GQLAbortUploadMutation>;
+export type UploadFileArgs = {
+    file: File;
+    onFileProgress: (key: string, percent: number) => void;
+    initiateUpload: InitiateUploadMutateAsync;
+    completeUpload: CompleteUploadMutateAsync;
+    abortUpload: AbortUploadMutateAsync;
+};
+export declare function uploadFile(args: UploadFileArgs): Promise<UploadedFileReference>;
+//# sourceMappingURL=upload-client.d.ts.map

package/dist/lib/upload-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-client.d.ts","sourceRoot":"","sources":["../../src/lib/upload-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,+BAA+B,EAC/B,yBAAyB,EACzB,kCAAkC,EAClC,yBAAyB,EACzB,kCAAkC,EACnC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAoB,MAAM,gCAAgC,CAAC;AAoCzG,wBAAsB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC,CAQjE;AA8CD,MAAM,MAAM,yBAAyB,GAAG,CACtC,SAAS,EAAE,kCAAkC,KAC1C,OAAO,CAAC,yBAAyB,CAAC,CAAC;AAExC,MAAM,MAAM,yBAAyB,GAAG,CACtC,SAAS,EAAE,kCAAkC,KAC1C,OAAO,CAAC,yBAAyB,CAAC,CAAC;AAExC,MAAM,MAAM,sBAAsB,GAAG,CAAC,SAAS,EAAE,+BAA+B,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAErH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,IAAI,CAAC;IACX,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACvD,cAAc,EAAE,yBAAyB,CAAC;IAC1C,cAAc,EAAE,yBAAyB,CAAC;IAC1C,WAAW,EAAE,sBAAsB,CAAC;CACrC,CAAC;AAEF,wBAAsB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAkErF"}

package/dist/lib/upload-client.js

@@ -0,0 +1,122 @@
+import { mediaTypeFromFileName, sha256Hex, uploadPartSize } from "@manta-eu/client/shared/upload";
+import { fileIdentityKey } from "@manta-eu/lib/file";
+import { isPresent } from "@manta-eu/lib/present";
+import { sum } from "ramda";
+const maxHashBytes = 50 * 1024 * 1024;
+async function computeSha256(file) {
+    if (file.size > maxHashBytes)
+        return;
+    try {
+        return await sha256Hex(await file.arrayBuffer());
+    }
+    catch {
+        return;
+    }
+}
+async function computeDimensions(file) {
+    const isImage = file.type.startsWith("image/") || mediaTypeFromFileName(file.name).startsWith("image/");
+    if (!isImage)
+        return;
+    let bitmap;
+    try {
+        bitmap = await createImageBitmap(file);
+        return { width: bitmap.width, height: bitmap.height };
+    }
+    catch {
+        return;
+    }
+    finally {
+        bitmap?.close();
+    }
+}
+export async function computeFacts(file) {
+    const [sha256, dimensions] = await Promise.all([computeSha256(file), computeDimensions(file)]);
+    return {
+        byteSize: file.size,
+        ...(isPresent(sha256) && { sha256 }),
+        ...(isPresent(dimensions) && { width: dimensions.width, height: dimensions.height }),
+    };
+}
+function putPart(args) {
+    const { url, blob, onProgress } = args;
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open("PUT", url);
+        xhr.upload.onprogress = (event) => {
+            if (event.lengthComputable)
+                onProgress(event.loaded);
+        };
+        xhr.onload = () => {
+            if (xhr.status < 200 || xhr.status >= 300) {
+                reject(new Error(`Part upload failed: ${xhr.status} ${xhr.statusText}`));
+                return;
+            }
+            const etag = xhr.getResponseHeader("ETag");
+            if (!etag) {
+                reject(new Error("Missing ETag on part response. R2 CORS must expose the ETag header."));
+                return;
+            }
+            resolve(etag);
+        };
+        xhr.onerror = () => reject(new Error("Network error during part upload"));
+        xhr.onabort = () => reject(new Error("Part upload aborted"));
+        xhr.ontimeout = () => reject(new Error("Part upload timed out"));
+        xhr.send(blob);
+    });
+}
+export async function uploadFile(args) {
+    const { file, onFileProgress, initiateUpload, completeUpload, abortUpload } = args;
+    const key = fileIdentityKey(file);
+    const factsPromise = computeFacts(file);
+    const initiate = await initiateUpload({ input: { fileName: file.name, byteSize: file.size } });
+    const { uploadId, storageKey, partUrls } = initiate.initiateUpload;
+    const loadedPerPart = new Array(partUrls.length).fill(0);
+    let lastReported = -1;
+    const reportProgress = () => {
+        const loaded = sum(loadedPerPart);
+        const percent = Math.min(100, Math.round((loaded / file.size) * 100));
+        if (percent === lastReported)
+            return;
+        lastReported = percent;
+        onFileProgress(key, percent);
+    };
+    try {
+        const parts = await Promise.all(partUrls.map(async (partUrl) => {
+            const partIndex = partUrl.partNumber - 1;
+            const start = partIndex * uploadPartSize;
+            const end = Math.min(start + uploadPartSize, file.size);
+            const blob = file.slice(start, end);
+            const etag = await putPart({
+                url: partUrl.url,
+                blob,
+                onProgress: (loaded) => {
+                    loadedPerPart[partIndex] = loaded;
+                    reportProgress();
+                },
+            });
+            loadedPerPart[partIndex] = end - start;
+            reportProgress();
+            return { partNumber: partUrl.partNumber, etag };
+        }));
+        const facts = await factsPromise;
+        const complete = await completeUpload({
+            input: { uploadId, storageKey, fileName: file.name, parts, facts },
+        });
+        return {
+            fileIri: complete.completeUpload.fileIri,
+            storageKey,
+            fileName: file.name,
+            mediaType: complete.completeUpload.mediaType,
+            byteSize: file.size,
+        };
+    }
+    catch (error) {
+        try {
+            await abortUpload({ input: { uploadId, storageKey } });
+        }
+        catch (abortError) {
+            console.warn(`Failed to abort multipart upload for ${file.name}`, abortError);
+        }
+        throw error;
+    }
+}

package/dist/lib/use-can-scroll.d.ts

@@ -0,0 +1,23 @@
+import { type RefObject } from "react";
+export type ScrollMetrics = Pick<HTMLElement, "scrollLeft" | "scrollTop" | "scrollWidth" | "scrollHeight" | "clientWidth" | "clientHeight">;
+export type ScrollAxis = "x" | "y" | "both";
+export declare function scrollEdges(metrics: ScrollMetrics, thresholdPx: number, axis: ScrollAxis): {
+    canScrollUp: boolean;
+    canScrollDown: boolean;
+    canScrollLeft: boolean;
+    canScrollRight: boolean;
+};
+export type UseCanScrollOptions<T extends HTMLElement> = {
+    axis: ScrollAxis;
+    ref?: RefObject<T | null>;
+    thresholdPx?: number;
+    observeMutations?: boolean;
+};
+export declare function useCanScroll<T extends HTMLElement = HTMLDivElement>(options: UseCanScrollOptions<T>): {
+    ref: RefObject<T | null>;
+    canScrollUp: boolean;
+    canScrollDown: boolean;
+    canScrollLeft: boolean;
+    canScrollRight: boolean;
+};
+//# sourceMappingURL=use-can-scroll.d.ts.map

package/dist/lib/use-can-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-can-scroll.d.ts","sourceRoot":"","sources":["../../src/lib/use-can-scroll.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEpE,MAAM,MAAM,aAAa,GAAG,IAAI,CAC9B,WAAW,EACX,YAAY,GAAG,WAAW,GAAG,aAAa,GAAG,cAAc,GAAG,aAAa,GAAG,cAAc,CAC7F,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC;AAE5C,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU;;;;;EAYxF;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,WAAW,IAAI;IACvD,IAAI,EAAE,UAAU,CAAC;IACjB,GAAG,CAAC,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,cAAc,EAAE,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;;;;;;EA2CnG"}

package/dist/lib/use-can-scroll.js

@@ -0,0 +1,45 @@
+import { useEffect, useRef, useState } from "react";
+export function scrollEdges(metrics, thresholdPx, axis) {
+    const { scrollLeft, scrollTop, scrollWidth, scrollHeight, clientWidth, clientHeight } = metrics;
+    const vertical = axis !== "x";
+    const horizontal = axis !== "y";
+    return {
+        canScrollUp: vertical && scrollTop >= thresholdPx,
+        canScrollDown: vertical && scrollHeight - scrollTop - clientHeight >= thresholdPx,
+        canScrollLeft: horizontal && scrollLeft >= thresholdPx,
+        canScrollRight: horizontal && scrollWidth - scrollLeft - clientWidth >= thresholdPx,
+    };
+}
+export function useCanScroll(options) {
+    const { axis, ref: externalRef, thresholdPx = 8, observeMutations = true } = options;
+    const internalRef = useRef(null);
+    const ref = externalRef ?? internalRef;
+    const [canScrollUp, setCanScrollUp] = useState(false);
+    const [canScrollDown, setCanScrollDown] = useState(false);
+    const [canScrollLeft, setCanScrollLeft] = useState(false);
+    const [canScrollRight, setCanScrollRight] = useState(false);
+    useEffect(() => {
+        const el = ref.current;
+        if (!el)
+            return;
+        const update = () => {
+            const edges = scrollEdges(el, thresholdPx, axis);
+            setCanScrollUp(edges.canScrollUp);
+            setCanScrollDown(edges.canScrollDown);
+            setCanScrollLeft(edges.canScrollLeft);
+            setCanScrollRight(edges.canScrollRight);
+        };
+        update();
+        el.addEventListener("scroll", update, { passive: true });
+        const resizeObserver = new ResizeObserver(update);
+        resizeObserver.observe(el);
+        const mutationObserver = observeMutations ? new MutationObserver(update) : undefined;
+        mutationObserver?.observe(el, { childList: true, subtree: true, characterData: true });
+        return () => {
+            el.removeEventListener("scroll", update);
+            resizeObserver.disconnect();
+            mutationObserver?.disconnect();
+        };
+    }, [ref, thresholdPx, observeMutations, axis]);
+    return { ref, canScrollUp, canScrollDown, canScrollLeft, canScrollRight };
+}

package/dist/lib/use-color-palette.d.ts

@@ -0,0 +1,5 @@
+export declare const useColorPalette: (imageSrc: string | undefined, paletteSize?: number) => {
+    palette: `#${string}`[];
+    isLoading: boolean;
+};
+//# sourceMappingURL=use-color-palette.d.ts.map

package/dist/lib/use-color-palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-color-palette.d.ts","sourceRoot":"","sources":["../../src/lib/use-color-palette.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,GAAG,SAAS,EAAE,oBAAe;;;CAyE5E,CAAC"}

package/dist/lib/use-color-palette.js

@@ -0,0 +1,82 @@
+import { getAverageColor, rgbToHex } from "@manta-eu/lib/color";
+import { createObjectURL } from "@manta-eu/lib/object-url";
+import { useEffect, useState } from "react";
+import { toast } from "sonner";
+const MAX_IMAGE_FILE_SIZE_MB_MOBILE = 20;
+const MB_TO_BYTES = 1024 * 1024;
+const isMobileDevice = () => {
+    const userAgent = navigator.userAgent ||
+        navigator.vendor ||
+        // TODO: This has been removed in Opera since 2013, remove
+        window.opera;
+    return /android|iphone|ipad|ipod/i.test(userAgent);
+};
+const fetchImageBlob = async (imageSrc) => {
+    const response = await fetch(imageSrc);
+    if (!response.ok) {
+        throw new Error("Failed to fetch the image");
+    }
+    return await response.blob();
+};
+export const useColorPalette = (imageSrc, paletteSize = 5) => {
+    const [palette, setPalette] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    useEffect(() => {
+        if (!imageSrc) {
+            setIsLoading(false);
+            return;
+        }
+        const loadImage = async () => {
+            try {
+                const imgBlob = await fetchImageBlob(imageSrc);
+                if (isMobileDevice()) {
+                    const fileSizeMB = imgBlob.size / MB_TO_BYTES;
+                    if (fileSizeMB > MAX_IMAGE_FILE_SIZE_MB_MOBILE) {
+                        setIsLoading(false);
+                        return;
+                    }
+                }
+                const img = new Image();
+                img.crossOrigin = "Anonymous";
+                img.onload = () => {
+                    const canvas = document.createElement("canvas");
+                    const ctx = canvas.getContext("2d");
+                    if (!ctx) {
+                        setIsLoading(false);
+                        return;
+                    }
+                    const { width, height } = img;
+                    canvas.width = width;
+                    canvas.height = height;
+                    ctx.drawImage(img, 0, 0, width, height);
+                    const blockSize = Math.floor(Math.min(width, height) / paletteSize);
+                    const colors = [];
+                    for (let i = 0; i < paletteSize; i++) {
+                        for (let j = 0; j < paletteSize; j++) {
+                            const regionColor = getAverageColor(ctx, blockSize, blockSize);
+                            colors.push(rgbToHex(regionColor));
+                            if (colors.length >= paletteSize)
+                                break;
+                        }
+                        if (colors.length >= paletteSize)
+                            break;
+                    }
+                    setPalette(colors);
+                    setIsLoading(false);
+                };
+                img.onerror = () => {
+                    console.error("Failed to load the image");
+                    setIsLoading(false);
+                };
+                img.src = createObjectURL(imgBlob);
+            }
+            catch (error) {
+                console.error(error);
+                toast.error("Failed to load the image");
+                setIsLoading(false);
+            }
+        };
+        void loadImage();
+    }, [imageSrc, paletteSize]);
+    return { palette, isLoading };
+};

package/dist/lib/use-copy-clipboard.d.ts

@@ -0,0 +1,6 @@
+export declare function useCopyToClipboard(): {
+    copied: boolean;
+    copiedValue: string | null;
+    copyToClipboard: (text: string) => Promise<boolean>;
+};
+//# sourceMappingURL=use-copy-clipboard.d.ts.map

package/dist/lib/use-copy-clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-clipboard.d.ts","sourceRoot":"","sources":["../../src/lib/use-copy-clipboard.ts"],"names":[],"mappings":"AAMA,wBAAgB,kBAAkB;;;4BAQjB,MAAM;EAyBtB"}

package/dist/lib/use-copy-clipboard.js

@@ -0,0 +1,34 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+import { useCopyToClipboard as useCopyToClipboardTs } from "usehooks-ts";
+const copiedResetDelayMs = 2000;
+export function useCopyToClipboard() {
+    const [copiedValue, copy] = useCopyToClipboardTs();
+    const [copied, setCopied] = useState(false);
+    const resetTimer = useRef(undefined);
+    useEffect(() => () => clearTimeout(resetTimer.current), []);
+    const copyToClipboard = useCallback(async (text) => {
+        try {
+            const success = await copy(text);
+            if (success) {
+                toast.success("Copied to clipboard");
+                setCopied(true);
+                clearTimeout(resetTimer.current);
+                resetTimer.current = setTimeout(() => setCopied(false), copiedResetDelayMs);
+            }
+            else {
+                toast.error("Failed to copy to clipboard");
+                clearTimeout(resetTimer.current);
+                setCopied(false);
+            }
+            return success;
+        }
+        catch {
+            toast.error("An error occurred while copying to clipboard");
+            clearTimeout(resetTimer.current);
+            setCopied(false);
+            return false;
+        }
+    }, [copy]);
+    return { copied, copiedValue, copyToClipboard };
+}

package/dist/lib/use-formatted-countdown.d.ts

@@ -0,0 +1,3 @@
+import { type DateArg } from "date-fns";
+export declare function useFormattedCountdown(targetDate?: DateArg<Date> | null): string;
+//# sourceMappingURL=use-formatted-countdown.d.ts.map

package/dist/lib/use-formatted-countdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-formatted-countdown.d.ts","sourceRoot":"","sources":["../../src/lib/use-formatted-countdown.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,UAAU,CAAC;AAGhD,wBAAgB,qBAAqB,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,UA+BtE"}

package/dist/lib/use-formatted-countdown.js

@@ -0,0 +1,26 @@
+import { humanDuration } from "@manta-eu/lib/humanize";
+import { isPast } from "date-fns";
+import { useEffect, useState } from "react";
+export function useFormattedCountdown(targetDate) {
+    const [countdown, setCountdown] = useState("");
+    useEffect(() => {
+        if (!targetDate) {
+            setCountdown("");
+            return;
+        }
+        function updateCountdown() {
+            if (isPast(targetDate)) {
+                setCountdown("");
+                return;
+            }
+            setCountdown(humanDuration({
+                start: Date.now(),
+                end: targetDate,
+            }));
+        }
+        updateCountdown();
+        const interval = setInterval(updateCountdown, 1000);
+        return () => clearInterval(interval);
+    }, [targetDate]);
+    return countdown;
+}

package/dist/lib/use-platform.d.ts

@@ -0,0 +1,10 @@
+export declare function usePlatform(): {
+    isIOS: boolean;
+    isMacOS: boolean;
+    isWindows: boolean;
+    isLinux: boolean;
+    isSafari: boolean;
+    isApple: boolean;
+    isDesktop: boolean;
+};
+//# sourceMappingURL=use-platform.d.ts.map

package/dist/lib/use-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-platform.d.ts","sourceRoot":"","sources":["../../src/lib/use-platform.ts"],"names":[],"mappings":"AAgBA,wBAAgB,WAAW;;;;;;;;EAsB1B"}

package/dist/lib/use-platform.js

@@ -0,0 +1,35 @@
+function getPlatformSafe() {
+    try {
+        return navigator.platform?.toLowerCase() ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+function getUserAgentSafe() {
+    try {
+        return navigator.userAgent.toLowerCase();
+    }
+    catch {
+        return "";
+    }
+}
+export function usePlatform() {
+    const userAgent = getUserAgentSafe();
+    const platform = getPlatformSafe();
+    const isIOS = /iphone|ipad|ipod/.test(userAgent) || (navigator.maxTouchPoints > 0 && /mac/.test(userAgent));
+    const isMacOS = (/mac/.test(userAgent) || /mac/.test(platform)) && !isIOS;
+    const isWindows = /win/.test(userAgent) || /win/.test(platform);
+    const isLinux = /linux/.test(userAgent) && !isIOS;
+    // Safari detection: contains "safari" but NOT "chrome", "chromium", or "crios" (Chrome on iOS)
+    const isSafari = /safari/i.test(userAgent) && !/chrome|chromium|crios/i.test(userAgent);
+    return {
+        isIOS,
+        isMacOS,
+        isWindows,
+        isLinux,
+        isSafari,
+        isApple: isMacOS || isIOS,
+        isDesktop: !isIOS && (isMacOS || isWindows || isLinux),
+    };
+}