@postrun/react 0.1.0

package/dist/index.js

@@ -0,0 +1,1284 @@
+"use client";
+import { createContext, memo, useMemo, useState, useEffect, Fragment as Fragment$1, useRef, createElement, useContext, useCallback } from 'react';
+import { useInfiniteQuery, useQuery, useMutation, QueryClient } from '@tanstack/react-query';
+import { createPostrunClient, profilesList, profilesGet, profilesCreate, profilesUpdate, profilesDelete, connectionsConnect, connectionsListByProfile, connectionsGet, connectionsListAccounts, connectionsSelect, connectionsDelete, mediaCreate, mediaGet, mediaUpdate, mediaDelete, postsList, postsGet, postsCreate, buildCreatePost, isPostPlatform, postsUpdate, postsDelete } from '@postrun/js';
+import pRetry, { AbortError } from 'p-retry';
+import pWaitFor from 'p-wait-for';
+import axios, { isAxiosError } from 'axios';
+import { enrichTweet, TweetContainer, TweetHeader, TweetInReplyTo, TweetBody, TweetMedia, QuotedTweet } from 'react-tweet';
+import { FiMessageCircle, FiRepeat, FiHeart, FiBarChart2, FiShare, FiGlobe, FiUsers, FiThumbsUp, FiMessageSquare, FiSend } from 'react-icons/fi';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import twitterText from 'twitter-text';
+import { LuBadgeCheck } from 'react-icons/lu';
+
+// src/context.tsx
+function createDefaultQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: { staleTime: 3e4 }
+    }
+  });
+}
+var PostrunContext = createContext(null);
+PostrunContext.displayName = "PostrunContext";
+function PostrunProvider({
+  getToken,
+  baseUrl,
+  queryClient,
+  children
+}) {
+  const getTokenRef = useRef(getToken);
+  useEffect(() => {
+    getTokenRef.current = getToken;
+  }, [getToken]);
+  const client = useMemo(
+    () => createPostrunClient({ getToken: () => getTokenRef.current(), baseUrl }),
+    [baseUrl]
+  );
+  const resolvedQueryClient = useMemo(
+    () => queryClient ?? createDefaultQueryClient(),
+    [queryClient]
+  );
+  const value = useMemo(
+    () => ({ client, queryClient: resolvedQueryClient }),
+    [client, resolvedQueryClient]
+  );
+  return createElement(PostrunContext.Provider, { value }, children);
+}
+function usePostrun() {
+  const value = useContext(PostrunContext);
+  if (value === null) {
+    throw new Error("usePostrun must be used within a <PostrunProvider>.");
+  }
+  return value;
+}
+function useInfiniteList(args) {
+  const { queryClient } = usePostrun();
+  const limit = args.limit ?? 20;
+  const query = useInfiniteQuery(
+    {
+      queryKey: args.queryKey,
+      queryFn: ({ pageParam }) => args.fetchPage({ limit, offset: pageParam }),
+      initialPageParam: 0,
+      getNextPageParam: (last) => last.has_more ? last.offset + last.data.length : void 0,
+      enabled: args.enabled
+    },
+    queryClient
+  );
+  return {
+    items: query.data?.pages.flatMap((page) => page.data) ?? [],
+    total: query.data?.pages[0]?.total ?? 0,
+    loadMore: () => {
+      void query.fetchNextPage();
+    },
+    hasMore: query.hasNextPage,
+    isLoading: query.isLoading,
+    isLoadingMore: query.isFetchingNextPage,
+    error: query.error,
+    refetch: () => {
+      void query.refetch();
+    }
+  };
+}
+
+// src/keys.ts
+var ROOT = "postrun";
+var profileKeys = {
+  all: [ROOT, "profiles"],
+  lists: () => [...profileKeys.all, "list"],
+  list: (query) => [...profileKeys.lists(), query ?? {}],
+  // Nested under lists() so a create/update/delete invalidating lists() also
+  // refreshes the infinite cache; distinct tail so the two cache shapes (a
+  // single Page vs accumulated pages) never collide on one key.
+  infinite: (query) => [...profileKeys.lists(), "infinite", query ?? {}],
+  details: () => [...profileKeys.all, "detail"],
+  detail: (id) => [...profileKeys.details(), id]
+};
+var postKeys = {
+  all: [ROOT, "posts"],
+  lists: () => [...postKeys.all, "list"],
+  list: (query) => [...postKeys.lists(), query ?? {}],
+  // Nested under lists() so a create/update/delete invalidating lists() also
+  // refreshes the infinite cache; distinct tail so the two cache shapes (a
+  // single Page vs accumulated pages) never collide on one key.
+  infinite: (query) => [...postKeys.lists(), "infinite", query ?? {}],
+  details: () => [...postKeys.all, "detail"],
+  detail: (id) => [...postKeys.details(), id]
+};
+var mediaKeys = {
+  all: [ROOT, "media"],
+  details: () => [...mediaKeys.all, "detail"],
+  detail: (id) => [...mediaKeys.details(), id]
+};
+var connectionKeys = {
+  all: [ROOT, "connections"],
+  lists: () => [...connectionKeys.all, "list"],
+  list: (profileId) => [...connectionKeys.lists(), profileId],
+  details: () => [...connectionKeys.all, "detail"],
+  detail: (id) => [...connectionKeys.details(), id],
+  accounts: (id) => [...connectionKeys.all, "accounts", id]
+};
+
+// src/profiles.ts
+function useProfiles(query) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: profileKeys.list(query),
+      queryFn: async () => (await profilesList({ client, query })).data
+    },
+    queryClient
+  );
+}
+function useProfilesInfinite(filters, options) {
+  const { client } = usePostrun();
+  return useInfiniteList({
+    queryKey: profileKeys.infinite(filters),
+    limit: options?.pageSize,
+    fetchPage: async ({ limit, offset }) => (await profilesList({ client, query: { ...filters, limit, offset } })).data
+  });
+}
+function useProfile(id) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: profileKeys.detail(id),
+      queryFn: async () => (await profilesGet({ client, path: { id } })).data,
+      enabled: Boolean(id)
+    },
+    queryClient
+  );
+}
+function useCreateProfile() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async (body) => (await profilesCreate({ client, body })).data,
+      onSuccess: () => queryClient.invalidateQueries({ queryKey: profileKeys.lists() })
+    },
+    queryClient
+  );
+}
+function useUpdateProfile() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async ({ id, ...body }) => (await profilesUpdate({ client, path: { id }, body })).data,
+      onSuccess: (_result, { id }) => {
+        queryClient.invalidateQueries({ queryKey: profileKeys.lists() });
+        queryClient.invalidateQueries({ queryKey: profileKeys.detail(id) });
+      }
+    },
+    queryClient
+  );
+}
+function useDeleteProfile() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async (id) => (await profilesDelete({ client, path: { id } })).data,
+      onSuccess: (_result, id) => {
+        queryClient.invalidateQueries({ queryKey: profileKeys.lists() });
+        queryClient.removeQueries({ queryKey: profileKeys.detail(id) });
+      }
+    },
+    queryClient
+  );
+}
+
+// src/navigate.ts
+function navigate(url) {
+  window.location.assign(url);
+}
+
+// src/connections.ts
+function useConnect() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async ({ profileId, platform }) => {
+        const session = (await connectionsConnect({
+          client,
+          path: { id: profileId },
+          body: { platform }
+        })).data;
+        navigate(session.connect_url);
+        return session;
+      }
+    },
+    queryClient
+  );
+}
+function useConnections(profileId) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: connectionKeys.list(profileId),
+      queryFn: async () => (await connectionsListByProfile({ client, path: { id: profileId } })).data,
+      enabled: Boolean(profileId)
+    },
+    queryClient
+  );
+}
+function useConnection(id) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: connectionKeys.detail(id),
+      queryFn: async () => (await connectionsGet({ client, path: { id } })).data,
+      enabled: Boolean(id)
+    },
+    queryClient
+  );
+}
+function useDiscoverableAccounts(id) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: connectionKeys.accounts(id),
+      queryFn: async () => (await connectionsListAccounts({ client, path: { id } })).data,
+      enabled: Boolean(id)
+    },
+    queryClient
+  );
+}
+function useSelectAccount() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async ({ id, ...body }) => (await connectionsSelect({ client, path: { id }, body })).data,
+      onSuccess: (_result, { id }) => {
+        queryClient.invalidateQueries({ queryKey: connectionKeys.lists() });
+        queryClient.invalidateQueries({ queryKey: connectionKeys.detail(id) });
+        queryClient.invalidateQueries({ queryKey: connectionKeys.accounts(id) });
+      }
+    },
+    queryClient
+  );
+}
+function useDisconnect() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async (id) => (await connectionsDelete({ client, path: { id } })).data,
+      onSuccess: (_result, id) => {
+        queryClient.invalidateQueries({ queryKey: connectionKeys.lists() });
+        queryClient.removeQueries({ queryKey: connectionKeys.detail(id) });
+      }
+    },
+    queryClient
+  );
+}
+var UploadError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "UploadError";
+    this.status = status;
+  }
+};
+async function uploadBytes(target, file, options = {}) {
+  const { onProgress, signal } = options;
+  try {
+    await axios.request({
+      method: target.method,
+      url: target.url,
+      data: file,
+      headers: target.headers,
+      signal,
+      onUploadProgress: (event) => {
+        if (event.total) {
+          onProgress?.(event.loaded / event.total);
+        }
+      }
+    });
+    onProgress?.(1);
+  } catch (error) {
+    if (signal?.aborted) {
+      throw error;
+    }
+    if (isAxiosError(error)) {
+      const status = error.response?.status ?? 0;
+      throw new UploadError(
+        status,
+        status ? `Upload failed (HTTP ${status}).` : "Upload failed: network error."
+      );
+    }
+    throw error;
+  }
+}
+
+// src/media.ts
+var DOCUMENT_MIME = /^application\/(pdf|msword|vnd\.(openxmlformats-officedocument\.(wordprocessingml\.document|presentationml\.presentation)|ms-powerpoint))$/;
+function inferKind(contentType) {
+  if (contentType === "image/gif") return "gif";
+  if (contentType.startsWith("image/")) return "image";
+  if (contentType.startsWith("video/")) return "video";
+  if (DOCUMENT_MIME.test(contentType)) return "document";
+  throw new Error(
+    `Could not infer media kind from "${contentType}". Pass { kind } explicitly.`
+  );
+}
+async function pollUntilSettled(client, id, signal) {
+  let latest;
+  await pWaitFor(
+    async () => {
+      if (signal.aborted) {
+        throw new DOMException("Upload aborted", "AbortError");
+      }
+      latest = (await mediaGet({ client, path: { id } })).data;
+      return latest.status === "ready" || latest.status === "failed";
+    },
+    { interval: 1500, timeout: 3e5 }
+  );
+  if (!latest) {
+    throw new Error("Media polling returned no result.");
+  }
+  return latest;
+}
+function useMediaUpload() {
+  const { client, queryClient } = usePostrun();
+  const [status, setStatus] = useState("idle");
+  const [progress, setProgress] = useState(0);
+  const [media, setMedia] = useState(null);
+  const [error, setError] = useState(null);
+  const abortRef = useRef(null);
+  const upload = useCallback(
+    async (file, options) => {
+      const contentType = options.contentType || file.type;
+      if (!contentType) {
+        throw new Error(
+          "Could not determine the file's content type. Pass { contentType } explicitly."
+        );
+      }
+      const kind = options.kind ?? inferKind(contentType);
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setStatus("uploading");
+      setProgress(0);
+      setMedia(null);
+      setError(null);
+      try {
+        const created = (await mediaCreate({
+          client,
+          body: {
+            profile_id: options.profileId,
+            kind,
+            content_type: contentType,
+            targets: options.targets,
+            raw: options.raw,
+            alt_text: options.altText,
+            external_id: options.externalId,
+            metadata: options.metadata
+          }
+        })).data;
+        if (created.upload) {
+          const target = created.upload;
+          await pRetry(
+            async () => {
+              try {
+                await uploadBytes(target, file, {
+                  onProgress: setProgress,
+                  signal: controller.signal
+                });
+              } catch (uploadError) {
+                if (uploadError instanceof UploadError && uploadError.status >= 400 && uploadError.status < 500) {
+                  throw new AbortError(uploadError);
+                }
+                throw uploadError;
+              }
+            },
+            { retries: 3, signal: controller.signal }
+          );
+        }
+        setStatus("processing");
+        const settled = await pollUntilSettled(
+          client,
+          created.id,
+          controller.signal
+        );
+        queryClient.setQueryData(mediaKeys.detail(created.id), settled);
+        setMedia(settled);
+        setStatus(settled.status === "failed" ? "failed" : "ready");
+        return settled;
+      } catch (caught) {
+        setError(caught);
+        setStatus("failed");
+        throw caught;
+      } finally {
+        if (abortRef.current === controller) {
+          abortRef.current = null;
+        }
+      }
+    },
+    [client, queryClient]
+  );
+  const cancel = useCallback(() => abortRef.current?.abort(), []);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setProgress(0);
+    setMedia(null);
+    setError(null);
+  }, []);
+  return { upload, cancel, reset, status, progress, media, error };
+}
+function useMedia(id) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: mediaKeys.detail(id),
+      queryFn: async () => (await mediaGet({ client, path: { id } })).data,
+      enabled: Boolean(id),
+      refetchInterval: (query) => {
+        const current = query.state.data;
+        return current?.status === "uploading" || current?.status === "processing" ? 2e3 : false;
+      }
+    },
+    queryClient
+  );
+}
+function useUpdateMedia() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async ({ id, ...body }) => (await mediaUpdate({ client, path: { id }, body })).data,
+      onSuccess: (result, { id }) => queryClient.setQueryData(mediaKeys.detail(id), result)
+    },
+    queryClient
+  );
+}
+function useDeleteMedia() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async (id) => (await mediaDelete({ client, path: { id } })).data,
+      onSuccess: (_result, id) => queryClient.removeQueries({ queryKey: mediaKeys.detail(id) })
+    },
+    queryClient
+  );
+}
+var IN_FLIGHT = /* @__PURE__ */ new Set([
+  "scheduled",
+  "publishing"
+]);
+var isLivePostStatus = (status) => IN_FLIGHT.has(status);
+function usePosts(query) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: postKeys.list(query),
+      queryFn: async () => (await postsList({ client, query })).data
+    },
+    queryClient
+  );
+}
+function usePostsInfinite(filters, options) {
+  const { client } = usePostrun();
+  return useInfiniteList({
+    queryKey: postKeys.infinite(filters),
+    limit: options?.pageSize,
+    fetchPage: async ({ limit, offset }) => (await postsList({ client, query: { ...filters, limit, offset } })).data
+  });
+}
+function useCalendar(filters, options) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: postKeys.list(filters),
+      queryFn: async () => (await postsList({ client, query: filters })).data,
+      refetchInterval: (query) => {
+        if (options?.live === false) return false;
+        const posts = query.state.data?.data ?? [];
+        return posts.some((post) => isLivePostStatus(post.status)) ? 5e3 : false;
+      }
+    },
+    queryClient
+  );
+}
+function usePost(id, options) {
+  const { client, queryClient } = usePostrun();
+  return useQuery(
+    {
+      queryKey: postKeys.detail(id),
+      queryFn: async () => (await postsGet({ client, path: { id } })).data,
+      enabled: Boolean(id),
+      refetchInterval: (query) => {
+        if (options?.live === false) return false;
+        const status = query.state.data?.status;
+        return status && isLivePostStatus(status) ? 2e3 : false;
+      }
+    },
+    queryClient
+  );
+}
+function useCreatePost(profileId) {
+  const { client, queryClient } = usePostrun();
+  const connections = useConnections(profileId);
+  const connected = connections.data?.data ?? [];
+  const mutation = useMutation(
+    {
+      mutationFn: async (input) => (await postsCreate({
+        client,
+        body: buildCreatePost({ ...input, profileId }, connected)
+      })).data,
+      onSuccess: () => queryClient.invalidateQueries({ queryKey: postKeys.lists() })
+    },
+    queryClient
+  );
+  return {
+    create: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset,
+    // The profile's connections must load before `create` can resolve a channel;
+    // gate on this so a call during loading isn't mislabeled "not connected".
+    isReady: connections.isSuccess,
+    connectedChannels: connected.map((connection) => connection.platform).filter(isPostPlatform)
+  };
+}
+function useUpdatePost(postId) {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async (body) => (await postsUpdate({ client, path: { id: postId }, body })).data,
+      onSuccess: (result) => {
+        queryClient.invalidateQueries({ queryKey: postKeys.lists() });
+        queryClient.setQueryData(postKeys.detail(postId), result);
+      }
+    },
+    queryClient
+  );
+}
+function useDeletePost() {
+  const { client, queryClient } = usePostrun();
+  return useMutation(
+    {
+      mutationFn: async (id) => (await postsDelete({ client, path: { id } })).data,
+      onSuccess: (_result, id) => {
+        queryClient.invalidateQueries({ queryKey: postKeys.lists() });
+        queryClient.removeQueries({ queryKey: postKeys.detail(id) });
+      }
+    },
+    queryClient
+  );
+}
+function fileKey(file) {
+  return file ? `${file.name}:${file.size}:${file.lastModified}` : "";
+}
+function mediaSignature(media) {
+  return (media ?? []).map((item) => {
+    const source = item.url ?? fileKey(item.file);
+    const size = `${item.width ?? ""}x${item.height ?? ""}`;
+    return `${item.kind}|${source}|${item.posterUrl ?? ""}|${size}|${item.alt ?? ""}`;
+  }).join("\xA7");
+}
+function altSignatureOf(media) {
+  return (media ?? []).map((m) => m?.alt_text_override ?? "").join("\xA7");
+}
+function useResolvedMedia(media, altFallbacks, altSignature) {
+  const signature = mediaSignature(media);
+  const [objectUrls, setObjectUrls] = useState({});
+  useEffect(() => {
+    const created = [];
+    const next = {};
+    (media ?? []).forEach((item, index) => {
+      if (!item.url && item.file) {
+        const url = URL.createObjectURL(item.file);
+        created.push(url);
+        next[index] = url;
+      }
+    });
+    setObjectUrls(next);
+    return () => {
+      for (const url of created) {
+        URL.revokeObjectURL(url);
+      }
+    };
+  }, [signature]);
+  return useMemo(
+    () => (media ?? []).flatMap((item, index) => {
+      const src = item.url ?? objectUrls[index];
+      if (!src) {
+        return [];
+      }
+      return [
+        {
+          kind: item.kind,
+          src,
+          width: item.width,
+          height: item.height,
+          alt: item.alt ?? altFallbacks?.[index]?.alt_text_override ?? void 0,
+          posterSrc: item.posterUrl
+        }
+      ];
+    }),
+    // `signature` + `altSignature` capture the content; `objectUrls` flips once
+    // File blobs resolve. Referencing `media`/`altFallbacks` directly is safe.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [signature, altSignature, objectUrls]
+  );
+}
+var ROW = {
+  display: "flex",
+  justifyContent: "space-between",
+  maxWidth: 425,
+  marginTop: 12,
+  color: "var(--tweet-color-gray-secondary, #536471)"
+};
+var ACTIONS = [
+  { label: "Reply", Icon: FiMessageCircle },
+  { label: "Repost", Icon: FiRepeat },
+  { label: "Like", Icon: FiHeart },
+  { label: "Views", Icon: FiBarChart2 },
+  { label: "Share", Icon: FiShare }
+];
+function XPreviewActions() {
+  return /* @__PURE__ */ jsx("div", { style: ROW, children: ACTIONS.map(({ label, Icon }) => /* @__PURE__ */ jsx(Icon, { size: 18, "aria-label": label, role: "img" }, label)) });
+}
+var {
+  extractCashtagsWithIndices,
+  extractHashtagsWithIndices,
+  extractMentionsWithIndices,
+  extractUrlsWithIndices,
+  modifyIndicesFromUTF16ToUnicode
+} = twitterText;
+function extractEntities(text) {
+  const hashtags = extractHashtagsWithIndices(text);
+  const mentions = extractMentionsWithIndices(text);
+  const urls = extractUrlsWithIndices(text);
+  const cashtags = extractCashtagsWithIndices(text);
+  modifyIndicesFromUTF16ToUnicode(text, [
+    ...hashtags,
+    ...mentions,
+    ...urls,
+    ...cashtags
+  ]);
+  return {
+    hashtags: hashtags.map((h) => ({ text: h.hashtag, indices: h.indices })),
+    user_mentions: mentions.map((m) => ({
+      id_str: "",
+      name: m.screenName,
+      screen_name: m.screenName,
+      indices: m.indices
+    })),
+    urls: urls.map((u) => ({
+      display_url: u.url,
+      expanded_url: u.url,
+      url: u.url,
+      indices: u.indices
+    })),
+    symbols: cashtags.map((c) => ({ text: c.cashtag, indices: c.indices }))
+  };
+}
+
+// src/preview/x/to-tweet.ts
+var PLACEHOLDER_AVATAR = "data:image/svg+xml;utf8," + encodeURIComponent(
+  '<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48"><circle cx="24" cy="24" r="24" fill="#cfd9de"/></svg>'
+);
+var FALLBACK_WIDTH = 1200;
+var FALLBACK_HEIGHT = 800;
+function codepointLength(text) {
+  return Array.from(text).length;
+}
+function buildUser(author) {
+  const verified = author.verified ?? false;
+  return {
+    id_str: "",
+    name: author.name,
+    profile_image_url_https: author.avatarUrl ?? PLACEHOLDER_AVATAR,
+    profile_image_shape: "Circle",
+    screen_name: author.handle,
+    verified: false,
+    is_blue_verified: verified
+  };
+}
+function mediaBase(src, width, height) {
+  const w = width ?? FALLBACK_WIDTH;
+  const h = height ?? FALLBACK_HEIGHT;
+  const size = { h, w, resize: "fit" };
+  return {
+    display_url: "",
+    expanded_url: "",
+    ext_media_availability: { status: "available" },
+    ext_media_color: { palette: [] },
+    indices: [0, 0],
+    media_url_https: src,
+    original_info: { height: h, width: w, focus_rects: [] },
+    sizes: { large: size, medium: size, small: size, thumb: size },
+    url: src
+  };
+}
+function buildPhoto(media) {
+  return {
+    ...mediaBase(media.src, media.width, media.height),
+    type: "photo",
+    ext_alt_text: media.alt
+  };
+}
+function buildVideo(media) {
+  const poster = media.posterSrc ?? media.src;
+  const videoInfo = {
+    aspect_ratio: [media.width ?? 16, media.height ?? 9],
+    variants: [{ content_type: "video/mp4", url: media.src }]
+  };
+  const base = mediaBase(poster, media.width, media.height);
+  return media.kind === "gif" ? { ...base, type: "animated_gif", video_info: videoInfo } : { ...base, type: "video", video_info: videoInfo };
+}
+function buildMediaDetails(media) {
+  return media.map(
+    (item) => item.kind === "image" ? buildPhoto(item) : buildVideo(item)
+  );
+}
+function tweetScaffold() {
+  return {
+    lang: "en",
+    created_at: "",
+    edit_control: {
+      edit_tweet_ids: [],
+      editable_until_msecs: "0",
+      is_edit_eligible: false,
+      edits_remaining: "0"
+    },
+    isEdited: false,
+    isStaleEdit: false,
+    favorite_count: 0,
+    conversation_count: 0,
+    news_action_type: "conversation"
+  };
+}
+function buildQuoted(quote, hasQuoteId) {
+  if (!quote && !hasQuoteId) {
+    return void 0;
+  }
+  const author = quote?.author ?? { name: "Quoted post", handle: "" };
+  const body = quote?.body ?? "";
+  const media = quote?.media ?? [];
+  return {
+    lang: "en",
+    created_at: "",
+    display_text_range: [0, codepointLength(body)],
+    entities: extractEntities(body),
+    id_str: "",
+    text: body,
+    user: buildUser(author),
+    edit_control: {
+      edit_tweet_ids: [],
+      editable_until_msecs: "0",
+      is_edit_eligible: false,
+      edits_remaining: "0"
+    },
+    isEdited: false,
+    isStaleEdit: false,
+    reply_count: 0,
+    retweet_count: 0,
+    favorite_count: 0,
+    self_thread: { id_str: "" },
+    ...media.length > 0 ? { mediaDetails: buildMediaDetails(media) } : {}
+  };
+}
+function toTweet(input) {
+  const { variant, author, media = [], quotedTweet, replyToHandle } = input;
+  const text = variant.body ?? "";
+  const mediaDetails = buildMediaDetails(media);
+  const quoted = buildQuoted(
+    quotedTweet,
+    variant.settings?.quote_tweet_id !== void 0
+  );
+  const reply = variant.settings?.reply;
+  return {
+    __typename: "Tweet",
+    ...tweetScaffold(),
+    // Codepoint length, not `text.length` (UTF-16) — react-tweet renders the
+    // body off `Array.from(text)`, so emoji must not shift the range.
+    display_text_range: [0, codepointLength(text)],
+    entities: extractEntities(text),
+    id_str: "",
+    text,
+    user: buildUser(author),
+    ...mediaDetails.length > 0 ? { mediaDetails } : {},
+    ...quoted ? { quoted_tweet: quoted } : {},
+    // Both the handle AND the parent id are needed: enrichTweet builds the
+    // reply link as `…/${screen_name}/status/${status_id_str}`, so omitting the
+    // id yields a `/status/undefined` href.
+    ...reply && replyToHandle ? {
+      in_reply_to_screen_name: replyToHandle,
+      in_reply_to_status_id_str: reply.in_reply_to_tweet_id
+    } : {}
+  };
+}
+function XPostPreviewImpl({
+  variant,
+  author,
+  media,
+  quotedTweet,
+  replyToHandle,
+  theme = "auto",
+  showActions = true,
+  className,
+  style,
+  components
+}) {
+  const resolvedMedia = useResolvedMedia(
+    media,
+    variant.media,
+    altSignatureOf(variant.media)
+  );
+  const resolvedQuotedMedia = useResolvedMedia(quotedTweet?.media, void 0, "");
+  const tweet = useMemo(() => {
+    const resolvedQuoted = quotedTweet ? {
+      author: quotedTweet.author,
+      body: quotedTweet.body,
+      media: resolvedQuotedMedia
+    } : void 0;
+    return enrichTweet(
+      toTweet({
+        variant,
+        author,
+        media: resolvedMedia,
+        quotedTweet: resolvedQuoted,
+        replyToHandle
+      })
+    );
+  }, [
+    variant,
+    author,
+    resolvedMedia,
+    quotedTweet,
+    resolvedQuotedMedia,
+    replyToHandle
+  ]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-theme": theme === "auto" ? void 0 : theme,
+      className,
+      style,
+      children: /* @__PURE__ */ jsxs(TweetContainer, { children: [
+        /* @__PURE__ */ jsx(TweetHeader, { tweet, components }),
+        tweet.in_reply_to_screen_name ? /* @__PURE__ */ jsx(TweetInReplyTo, { tweet }) : null,
+        /* @__PURE__ */ jsx(TweetBody, { tweet }),
+        tweet.mediaDetails?.length ? /* @__PURE__ */ jsx(TweetMedia, { tweet, components }) : null,
+        tweet.quoted_tweet ? /* @__PURE__ */ jsx(QuotedTweet, { tweet: tweet.quoted_tweet }) : null,
+        showActions ? /* @__PURE__ */ jsx(XPreviewActions, {}) : null
+      ] })
+    }
+  );
+}
+var XPostPreview = memo(XPostPreviewImpl);
+var LI_VAR = {
+  bg: "--pr-li-bg",
+  text: "--pr-li-text",
+  muted: "--pr-li-muted",
+  border: "--pr-li-border",
+  accent: "--pr-li-accent"
+};
+var LIGHT = {
+  bg: "#ffffff",
+  text: "rgba(0,0,0,0.9)",
+  muted: "rgba(0,0,0,0.6)",
+  border: "rgba(0,0,0,0.08)",
+  accent: "rgb(10,102,194)"
+};
+var DARK = {
+  bg: "#1b1f23",
+  text: "rgba(255,255,255,0.9)",
+  muted: "rgba(255,255,255,0.6)",
+  border: "rgba(255,255,255,0.15)",
+  accent: "rgb(112,181,249)"
+};
+function varRef(name) {
+  return `var(${name})`;
+}
+function paletteVars(dark) {
+  const p = dark ? DARK : LIGHT;
+  return {
+    "--pr-li-bg": p.bg,
+    "--pr-li-text": p.text,
+    "--pr-li-muted": p.muted,
+    "--pr-li-border": p.border,
+    "--pr-li-accent": p.accent
+  };
+}
+function usePrefersDark() {
+  const [dark, setDark] = useState(false);
+  useEffect(() => {
+    if (typeof window === "undefined" || !window.matchMedia) {
+      return;
+    }
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    setDark(mq.matches);
+    const onChange = (event) => setDark(event.matches);
+    mq.addEventListener("change", onChange);
+    return () => mq.removeEventListener("change", onChange);
+  }, []);
+  return dark;
+}
+function useIsDark(theme) {
+  const prefersDark = usePrefersDark();
+  if (theme === "auto") {
+    return prefersDark;
+  }
+  return theme === "dark";
+}
+var ROW2 = {
+  display: "flex",
+  justifyContent: "space-around",
+  borderTop: `1px solid ${varRef(LI_VAR.border)}`,
+  marginTop: 8,
+  padding: "4px 8px"
+};
+var ITEM = {
+  display: "flex",
+  alignItems: "center",
+  gap: 6,
+  padding: "8px",
+  color: varRef(LI_VAR.muted),
+  fontSize: 14,
+  fontWeight: 600
+};
+var ACTIONS2 = [
+  { label: "Like", Icon: FiThumbsUp },
+  { label: "Comment", Icon: FiMessageSquare },
+  { label: "Repost", Icon: FiRepeat },
+  { label: "Send", Icon: FiSend }
+];
+function EngagementBar() {
+  return /* @__PURE__ */ jsx("div", { style: ROW2, children: ACTIONS2.map(({ label, Icon }) => /* @__PURE__ */ jsxs("span", { style: ITEM, children: [
+    /* @__PURE__ */ jsx(Icon, { size: 20, "aria-hidden": true }),
+    label
+  ] }, label)) });
+}
+var PLACEHOLDER_AVATAR2 = "data:image/svg+xml;utf8," + encodeURIComponent(
+  '<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48"><circle cx="24" cy="24" r="24" fill="#9aa6b2"/></svg>'
+);
+function Header({ author, visibility, time = "Now" }) {
+  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 8, padding: "12px 16px 0" }, children: [
+    /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: author.avatarUrl ?? PLACEHOLDER_AVATAR2,
+        alt: "",
+        width: 48,
+        height: 48,
+        style: { width: 48, height: 48, borderRadius: "50%", objectFit: "cover", flex: "0 0 auto" }
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { style: { minWidth: 0, display: "flex", flexDirection: "column" }, children: [
+      /* @__PURE__ */ jsxs(
+        "span",
+        {
+          style: {
+            display: "flex",
+            alignItems: "center",
+            fontSize: 14,
+            fontWeight: 600,
+            color: varRef(LI_VAR.text),
+            lineHeight: 1.3
+          },
+          children: [
+            author.name,
+            author.verified ? /* @__PURE__ */ jsx(
+              LuBadgeCheck,
+              {
+                size: 16,
+                "aria-label": "Verified",
+                role: "img",
+                style: { color: varRef(LI_VAR.accent), marginLeft: 3, flex: "0 0 auto" }
+              }
+            ) : null
+          ]
+        }
+      ),
+      author.headline ? /* @__PURE__ */ jsx("span", { style: { fontSize: 12, color: varRef(LI_VAR.muted), lineHeight: 1.3 }, children: author.headline }) : null,
+      /* @__PURE__ */ jsxs(
+        "span",
+        {
+          style: {
+            display: "flex",
+            alignItems: "center",
+            gap: 4,
+            fontSize: 12,
+            color: varRef(LI_VAR.muted),
+            lineHeight: 1.3
+          },
+          children: [
+            time,
+            " \u2022",
+            " ",
+            visibility === "PUBLIC" ? /* @__PURE__ */ jsx(FiGlobe, { size: 13, "aria-label": "Public", role: "img" }) : /* @__PURE__ */ jsx(FiUsers, { size: 13, "aria-label": "Connections", role: "img" })
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+var MAX_TILES = 4;
+var MOSAIC_HEIGHT = 272;
+var GRID_BASE = {
+  display: "grid",
+  gap: 2,
+  height: MOSAIC_HEIGHT,
+  overflow: "hidden"
+};
+function gridStyle(tiles) {
+  if (tiles === 2) {
+    return { ...GRID_BASE, gridTemplateColumns: "1fr 1fr" };
+  }
+  if (tiles === 3) {
+    return {
+      ...GRID_BASE,
+      gridTemplateColumns: "1fr 1fr",
+      gridTemplateRows: "1fr 1fr",
+      gridTemplateAreas: '"a b" "a c"'
+    };
+  }
+  return {
+    ...GRID_BASE,
+    gridTemplateColumns: "1fr 1fr",
+    gridTemplateRows: "1fr 1fr"
+  };
+}
+var IMG_STYLE = {
+  width: "100%",
+  height: "100%",
+  objectFit: "cover",
+  display: "block"
+};
+var AREAS = ["a", "b", "c"];
+function Tile({
+  item,
+  area,
+  overlay
+}) {
+  return /* @__PURE__ */ jsxs("div", { style: { position: "relative", gridArea: area, overflow: "hidden" }, children: [
+    /* @__PURE__ */ jsx("img", { src: item.src, alt: item.alt ?? "", style: IMG_STYLE }),
+    overlay ? /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-hidden": false,
+        style: {
+          position: "absolute",
+          inset: 0,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          background: "rgba(0,0,0,0.5)",
+          color: "#fff",
+          fontSize: 28,
+          fontWeight: 600
+        },
+        children: `+${overlay}`
+      }
+    ) : null
+  ] });
+}
+function ImageMosaic({ media }) {
+  if (media.length === 0) {
+    return null;
+  }
+  if (media.length === 1) {
+    const only = media[0];
+    return /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: only.src,
+        alt: only.alt ?? "",
+        style: { width: "100%", height: "auto", display: "block" }
+      }
+    );
+  }
+  const tiles = media.slice(0, MAX_TILES);
+  const hidden = media.length - MAX_TILES;
+  return /* @__PURE__ */ jsx("div", { style: gridStyle(tiles.length), children: tiles.map((item, index) => /* @__PURE__ */ jsx(
+    Tile,
+    {
+      item,
+      area: tiles.length === 3 ? AREAS[index] : void 0,
+      overlay: hidden > 0 && index === MAX_TILES - 1 ? hidden : void 0
+    },
+    item.src + index
+  )) });
+}
+function VideoTile({ item }) {
+  return /* @__PURE__ */ jsx(
+    "video",
+    {
+      src: item.src,
+      poster: item.posterSrc,
+      controls: true,
+      style: { width: "100%", display: "block", background: "#000" }
+    }
+  );
+}
+function Media({ media }) {
+  if (media.length === 0) {
+    return null;
+  }
+  const video = media.find(
+    (item) => item.kind === "video" || item.kind === "gif"
+  );
+  if (video) {
+    return /* @__PURE__ */ jsx(VideoTile, { item: video });
+  }
+  const images = media.filter((item) => item.kind === "image");
+  return /* @__PURE__ */ jsx(ImageMosaic, { media: images });
+}
+var FOLD_CHARS = 200;
+var BODY_STYLE = {
+  whiteSpace: "pre-wrap",
+  wordBreak: "break-word",
+  fontSize: 14,
+  lineHeight: 1.43
+};
+function truncateAtWord(text, max) {
+  if (text.length <= max) {
+    return text;
+  }
+  const slice = text.slice(0, max);
+  const lastSpace = slice.lastIndexOf(" ");
+  return slice.slice(0, lastSpace > 0 ? lastSpace : max);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildPattern(mentionNames) {
+  const mentionAlt = mentionNames.filter((name) => name.trim().length > 0).map(escapeRegExp).join("|");
+  const parts = [
+    "https?:\\/\\/[^\\s]+",
+    // urls
+    "#[\\p{L}\\p{N}_]+",
+    // hashtags (unicode-aware)
+    ...mentionAlt ? [mentionAlt] : []
+  ];
+  return new RegExp(`(${parts.join("|")})`, "gu");
+}
+function linkStyle(color) {
+  return { color, textDecoration: "none", fontWeight: 500 };
+}
+function linkify(text, colors, mentionNames) {
+  const pattern = buildPattern(mentionNames);
+  const nodes = [];
+  let lastIndex = 0;
+  let key = 0;
+  for (const match of text.matchAll(pattern)) {
+    const token = match[0];
+    const start = match.index;
+    if (start > lastIndex) {
+      nodes.push(
+        /* @__PURE__ */ jsx(Fragment$1, { children: text.slice(lastIndex, start) }, key++)
+      );
+    }
+    if (token.startsWith("http")) {
+      nodes.push(
+        /* @__PURE__ */ jsx(
+          "a",
+          {
+            href: token,
+            style: linkStyle(colors.accent),
+            target: "_blank",
+            rel: "noreferrer",
+            children: token
+          },
+          key++
+        )
+      );
+    } else if (token.startsWith("#")) {
+      nodes.push(
+        /* @__PURE__ */ jsx("a", { href: "#", style: linkStyle(colors.accent), children: token }, key++)
+      );
+    } else {
+      nodes.push(
+        /* @__PURE__ */ jsx("span", { style: linkStyle(colors.accent), children: token }, key++)
+      );
+    }
+    lastIndex = start + token.length;
+  }
+  if (lastIndex < text.length) {
+    nodes.push(/* @__PURE__ */ jsx(Fragment$1, { children: text.slice(lastIndex) }, key++));
+  }
+  return nodes;
+}
+function PostBody({ text, mentionNames = [], colors }) {
+  const [expanded, setExpanded] = useState(false);
+  const isLong = text.length > FOLD_CHARS;
+  const shown = isLong && !expanded ? truncateAtWord(text, FOLD_CHARS) : text;
+  return /* @__PURE__ */ jsxs("div", { style: BODY_STYLE, children: [
+    linkify(shown, colors, mentionNames),
+    isLong && !expanded ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      "\u2026",
+      " ",
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => setExpanded(true),
+          style: {
+            background: "none",
+            border: "none",
+            padding: 0,
+            cursor: "pointer",
+            color: colors.muted,
+            fontWeight: 600,
+            fontSize: 14
+          },
+          children: "more"
+        }
+      )
+    ] }) : null
+  ] });
+}
+var FONT_STACK = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif';
+function LinkedInPostPreviewImpl({
+  variant,
+  author,
+  media,
+  theme = "auto",
+  time,
+  showActions = true,
+  className,
+  style
+}) {
+  const dark = useIsDark(theme);
+  const resolvedMedia = useResolvedMedia(
+    media,
+    variant.media,
+    altSignatureOf(variant.media)
+  );
+  const visibility = variant.settings?.visibility ?? "PUBLIC";
+  const mentionNames = (variant.settings?.mentions ?? []).map((m) => m.name);
+  const bodyColors = {
+    accent: varRef(LI_VAR.accent),
+    muted: varRef(LI_VAR.muted)
+  };
+  const cardStyle = {
+    ...paletteVars(dark),
+    background: varRef(LI_VAR.bg),
+    color: varRef(LI_VAR.text),
+    border: `1px solid ${varRef(LI_VAR.border)}`,
+    borderRadius: 10,
+    maxWidth: 552,
+    overflow: "hidden",
+    fontFamily: FONT_STACK,
+    ...style
+  };
+  return /* @__PURE__ */ jsxs("div", { className, style: cardStyle, children: [
+    /* @__PURE__ */ jsx(Header, { author, visibility, time }),
+    variant.body ? /* @__PURE__ */ jsx("div", { style: { padding: "8px 16px 0" }, children: /* @__PURE__ */ jsx(
+      PostBody,
+      {
+        text: variant.body,
+        mentionNames,
+        colors: bodyColors
+      }
+    ) }) : null,
+    resolvedMedia.length > 0 ? /* @__PURE__ */ jsx("div", { style: { marginTop: 12 }, children: /* @__PURE__ */ jsx(Media, { media: resolvedMedia }) }) : null,
+    showActions ? /* @__PURE__ */ jsx(EngagementBar, {}) : null
+  ] });
+}
+var LinkedInPostPreview = memo(LinkedInPostPreviewImpl);
+
+export { LinkedInPostPreview, PostrunProvider, UploadError, XPostPreview, connectionKeys, mediaKeys, postKeys, profileKeys, useCalendar, useConnect, useConnection, useConnections, useCreatePost, useCreateProfile, useDeleteMedia, useDeletePost, useDeleteProfile, useDisconnect, useDiscoverableAccounts, useInfiniteList, useMedia, useMediaUpload, usePost, usePostrun, usePosts, usePostsInfinite, useProfile, useProfiles, useProfilesInfinite, useSelectAccount, useUpdateMedia, useUpdatePost, useUpdateProfile };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map