@react-native-kakao/share 3.0.0 → 3.1.0-next.1

package/src/index.web.ts

@@ -1,10 +1,42 @@
-import { filterNonNullishKeys, snakeCaseObject } from '@mj-studio/js-util';
-import { kRunWebAPI } from '@react-native-kakao/core';
+import {
+  filterNonNullishKeys,
+  replaceJsonValuesRecursively,
+  snakeCaseObject,
+} from '@mj-studio/js-util';
+import { kCreateWebError, kRunWebAPI } from '@react-native-kakao/core';
 
-import type { KakaoShareAPI } from './index';
+import type {
+  KakaoFriendMessageResult,
+  KakaoImageUploadResult,
+  KakaoMessageSendResult,
+  KakaoShareAPI,
+  KakaoSharePickerSettings,
+} from './index';
+import { validateSharePickerSettings } from './validateSharePickerSettings';
 
 declare const Kakao: {
   Share: {
+    uploadImage: (args: { file: Blob[] }) => Promise<{
+      infos: {
+        original: Omit<KakaoImageUploadResult['infos']['original'], 'contentType'> & {
+          content_type: string;
+        };
+      };
+    }>;
+    sendScrap: (args: {
+      requestUrl: string;
+      templateId?: number;
+      templateArgs: Record<string, string>;
+      serverCallbackArgs: Record<string, string>;
+      pickerSettings?: KakaoSharePickerSettings;
+    }) => void;
+    scrapImage: (args: { imageUrl: string }) => Promise<{
+      infos: {
+        original: Omit<KakaoImageUploadResult['infos']['original'], 'contentType'> & {
+          content_type: string;
+        };
+      };
+    }>;
     sendDefault: (args: any) => Promise<any>;
     sendCustom: (args: any) => Promise<any>;
   };
@@ -15,121 +47,332 @@ function createShareDefault({
   serverCallbackArgs,
   template,
   objectType,
+  pickerSettings,
 }: {
   objectType: string;
   template: any;
   serverCallbackArgs?: Record<string, string>;
+  pickerSettings?: KakaoSharePickerSettings;
 }) {
   return kRunWebAPI(() =>
-    Kakao.Share.sendDefault({
-      objectType,
-      ...template,
-      serverCallbackArgs,
-    }),
+    Kakao.Share.sendDefault(
+      filterNonNullishKeys({
+        objectType,
+        ...serializeExecutionParams(template),
+        serverCallbackArgs,
+        pickerSettings: validateSharePickerSettings(pickerSettings),
+      }),
+    ),
   );
 }
 
 function createSendDefaultMe({ template, objectType }: { objectType: string; template: any }) {
-  return kRunWebAPI(() =>
-    Kakao.API.request({
+  return kRunWebAPI(async () => {
+    await Kakao.API.request({
       url: '/v2/api/talk/memo/default/send',
       data: {
-        template_object: snakeCaseObject({
-          objectType,
-          ...template,
-        }),
+        template_object: serializeMessageTemplate(objectType, template),
       },
-    }),
-  );
+    });
+  });
+}
+
+type WebMessageSendResult = {
+  successful_receiver_uuids?: string[];
+  failure_info?: { code: number; msg: string; receiver_uuids: string[] }[];
+};
+
+function getFriendMessageResult<T extends boolean = false>(
+  response: WebMessageSendResult,
+  includeFailureInfo?: T,
+): KakaoFriendMessageResult<T>;
+function getFriendMessageResult(
+  response: WebMessageSendResult,
+  includeFailureInfo?: boolean,
+): string[] | KakaoMessageSendResult {
+  const successfulReceiverUuids = response.successful_receiver_uuids ?? [];
+
+  return includeFailureInfo
+    ? {
+        successfulReceiverUuids,
+        failureInfos: (response.failure_info ?? []).map(({ receiver_uuids, ...failure }) => ({
+          ...failure,
+          receiverUuids: receiver_uuids,
+        })),
+      }
+    : successfulReceiverUuids;
 }
 
-function createSendDefaultFriends({
+function createSendDefaultFriends<T extends boolean = false>({
   objectType,
   template,
   receiverUuids,
+  includeFailureInfo,
 }: {
   template: any;
   objectType: any;
   receiverUuids: string[];
+  includeFailureInfo?: T;
 }) {
   return kRunWebAPI(() =>
     Kakao.API.request({
       url: '/v1/api/talk/friends/message/default/send',
       data: {
-        template_object: snakeCaseObject(
-          filterNonNullishKeys({
-            objectType,
-            ...template,
-          }),
-        ),
+        template_object: serializeMessageTemplate(objectType, template),
         receiver_uuids: receiverUuids,
       },
-    }),
+    }).then((response: WebMessageSendResult) =>
+      getFriendMessageResult(response, includeFailureInfo),
+    ),
   );
 }
 
+function serializeMessageTemplate(objectType: string, template: object) {
+  return snakeCaseObject({ objectType, ...serializeExecutionParams(template) });
+}
+
+function serializeExecutionParams(template: object) {
+  return replaceJsonValuesRecursively(template, {
+    stripUndefined: true,
+    replacer: {
+      androidExecutionParams: encodeExecutionParams,
+      iosExecutionParams: encodeExecutionParams,
+    },
+  });
+
+  function encodeExecutionParams(params?: Record<string, string>) {
+    return params == null
+      ? undefined
+      : Object.entries(params)
+          .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+          .join('&');
+  }
+}
+
 const KakaoShare: KakaoShareAPI = {
-  shareCustomTemplate: ({ templateArgs, templateId, serverCallbackArgs }) =>
+  isKakaoTalkSharingAvailable: async () => false,
+  getShareTemplateDiagnostics: async () => {
+    kCreateWebError({
+      code: 'Package-UnsupportedPlatform',
+      message: 'The Kakao JavaScript SDK does not expose sharing template diagnostics.',
+    });
+  },
+  makeDefaultTemplateUrl: unsupportedUrlBuilder,
+  makeCustomTemplateUrl: unsupportedUrlBuilder,
+  makeScrapTemplateUrl: unsupportedUrlBuilder,
+  uploadImage: ({ imageUri, secureResource = true }) =>
+    kRunWebAPI(async () => {
+      const response = await fetch(imageUri);
+      if (!response.ok) {
+        throw new Error(`Failed to read image: HTTP ${response.status}`);
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error('Image response has no body');
+      }
+
+      const chunks: BlobPart[] = [];
+      let length = 0;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+
+          length += value.byteLength;
+          if (length > 5 * 1024 * 1024) {
+            await reader.cancel();
+            throw new Error('Image must be no larger than 5 MB');
+          }
+
+          chunks.push(value);
+        }
+      } finally {
+        reader.releaseLock();
+      }
+
+      const image = new Blob(chunks, { type: response.headers.get('content-type') ?? '' });
+
+      const { infos } = await Kakao.Share.uploadImage({ file: [image] });
+      const { content_type: contentType, ...original } = infos.original;
+
+      return {
+        infos: {
+          original: {
+            ...original,
+            url: original.url.replace(/^https?:/, secureResource ? 'https:' : 'http:'),
+            contentType,
+          },
+        },
+      };
+    }),
+  shareScrapTemplate: ({
+    requestUrl,
+    templateId,
+    templateArgs = {},
+    serverCallbackArgs = {},
+    pickerSettings,
+  }) =>
     kRunWebAPI(() =>
-      Kakao.Share.sendCustom({
-        templateId,
-        templateArgs,
-        serverCallbackArgs,
-      }),
+      Kakao.Share.sendScrap(
+        filterNonNullishKeys({
+          requestUrl,
+          templateId,
+          templateArgs,
+          serverCallbackArgs,
+          pickerSettings: validateSharePickerSettings(pickerSettings),
+        }),
+      ),
     ),
-  sendCustomTemplateToMe: ({ templateId, templateArgs }) =>
-    kRunWebAPI(() =>
+  sendScrapTemplateToMe: async ({ requestUrl, templateId, templateArgs }) => {
+    await kRunWebAPI(() =>
       Kakao.API.request({
-        url: '/v2/api/talk/memo/send',
-        data: { template_id: templateId, template_args: templateArgs },
+        url: '/v2/api/talk/memo/scrap/send',
+        data: filterNonNullishKeys({
+          request_url: requestUrl,
+          template_id: templateId,
+          template_args: templateArgs,
+        }),
+      }),
+    );
+  },
+  sendScrapTemplateToFriends: async ({
+    requestUrl,
+    templateId,
+    templateArgs,
+    receiverUuids,
+    includeFailureInfo,
+  }) => {
+    const response: WebMessageSendResult = await kRunWebAPI(() =>
+      Kakao.API.request({
+        url: '/v1/api/talk/friends/message/scrap/send',
+        data: filterNonNullishKeys({
+          request_url: requestUrl,
+          template_id: templateId,
+          template_args: templateArgs,
+          receiver_uuids: receiverUuids,
+        }),
       }),
+    );
+
+    return getFriendMessageResult(response, includeFailureInfo);
+  },
+  scrapImage: ({ imageUrl, secureResource = true }) =>
+    kRunWebAPI(async () => {
+      const { infos } = await Kakao.Share.scrapImage({ imageUrl });
+      const { content_type: contentType, ...original } = infos.original;
+
+      return {
+        infos: {
+          original: {
+            ...original,
+            url: original.url.replace(/^https?:/, secureResource ? 'https:' : 'http:'),
+            contentType,
+          },
+        },
+      };
+    }),
+  shareCustomTemplate: ({ templateArgs, templateId, serverCallbackArgs, pickerSettings }) =>
+    kRunWebAPI(() =>
+      Kakao.Share.sendCustom(
+        filterNonNullishKeys({
+          templateId,
+          templateArgs,
+          serverCallbackArgs,
+          pickerSettings: validateSharePickerSettings(pickerSettings),
+        }),
+      ),
     ),
-  sendCustomTemplateToFriends: ({ templateArgs, templateId, receiverUuids }) =>
+  sendCustomTemplateToMe: ({ templateId, templateArgs }) =>
+    kRunWebAPI(async () => {
+      await Kakao.API.request({
+        url: '/v2/api/talk/memo/send',
+        data: filterNonNullishKeys({ template_id: templateId, template_args: templateArgs }),
+      });
+    }),
+  sendCustomTemplateToFriends: ({ templateArgs, templateId, receiverUuids, includeFailureInfo }) =>
     kRunWebAPI(() =>
       Kakao.API.request({
         url: '/v1/api/talk/friends/message/send',
-        data: {
+        data: filterNonNullishKeys({
           template_id: templateId,
           template_args: templateArgs,
           receiver_uuids: receiverUuids,
-        },
-      }),
+        }),
+      }).then((response: WebMessageSendResult) =>
+        getFriendMessageResult(response, includeFailureInfo),
+      ),
     ),
-  shareFeedTemplate: ({ template, serverCallbackArgs }) =>
-    createShareDefault({ template, serverCallbackArgs, objectType: 'feed' }),
+  shareFeedTemplate: ({ template, serverCallbackArgs, pickerSettings }) =>
+    createShareDefault({ template, serverCallbackArgs, pickerSettings, objectType: 'feed' }),
   sendFeedTemplateToMe: ({ template }) => createSendDefaultMe({ template, objectType: 'feed' }),
-  sendFeedTemplateToFriends: ({ template, receiverUuids }) =>
-    createSendDefaultFriends({ template, receiverUuids, objectType: 'feed' }),
-  shareListTemplate: ({ template, serverCallbackArgs }) =>
-    createShareDefault({ template, serverCallbackArgs, objectType: 'list' }),
+  sendFeedTemplateToFriends: ({ template, receiverUuids, includeFailureInfo }) =>
+    createSendDefaultFriends({ template, receiverUuids, includeFailureInfo, objectType: 'feed' }),
+  shareListTemplate: ({ template, serverCallbackArgs, pickerSettings }) =>
+    createShareDefault({ template, serverCallbackArgs, pickerSettings, objectType: 'list' }),
   sendListTemplateToMe: ({ template }) => createSendDefaultMe({ template, objectType: 'list' }),
-  sendListTemplateToFriends: ({ template, receiverUuids }) =>
-    createSendDefaultFriends({ template, receiverUuids, objectType: 'list' }),
-  shareLocationTemplate: ({ template, serverCallbackArgs }) =>
-    createShareDefault({ template, serverCallbackArgs, objectType: 'location' }),
+  sendListTemplateToFriends: ({ template, receiverUuids, includeFailureInfo }) =>
+    createSendDefaultFriends({ template, receiverUuids, includeFailureInfo, objectType: 'list' }),
+  shareLocationTemplate: ({ template, serverCallbackArgs, pickerSettings }) =>
+    createShareDefault({ template, serverCallbackArgs, pickerSettings, objectType: 'location' }),
   sendLocationTemplateToMe: ({ template }) =>
     createSendDefaultMe({ template, objectType: 'location' }),
-  sendLocationTemplateToFriends: ({ template, receiverUuids }) =>
-    createSendDefaultFriends({ template, receiverUuids, objectType: 'location' }),
-  shareCommerceTemplate: ({ template, serverCallbackArgs }) =>
-    createShareDefault({ template, serverCallbackArgs, objectType: 'commerce' }),
+  sendLocationTemplateToFriends: ({ template, receiverUuids, includeFailureInfo }) =>
+    createSendDefaultFriends({
+      template,
+      receiverUuids,
+      includeFailureInfo,
+      objectType: 'location',
+    }),
+  shareCommerceTemplate: ({ template, serverCallbackArgs, pickerSettings }) =>
+    createShareDefault({ template, serverCallbackArgs, pickerSettings, objectType: 'commerce' }),
   sendCommerceTemplateToMe: ({ template }) =>
     createSendDefaultMe({ template, objectType: 'commerce' }),
-  sendCommerceTemplateToFriends: ({ template, receiverUuids }) =>
-    createSendDefaultFriends({ template, receiverUuids, objectType: 'commerce' }),
-  shareTextTemplate: ({ template, serverCallbackArgs }) =>
-    createShareDefault({ template, serverCallbackArgs, objectType: 'text' }),
+  sendCommerceTemplateToFriends: ({ template, receiverUuids, includeFailureInfo }) =>
+    createSendDefaultFriends({
+      template,
+      receiverUuids,
+      includeFailureInfo,
+      objectType: 'commerce',
+    }),
+  shareTextTemplate: ({ template, serverCallbackArgs, pickerSettings }) =>
+    createShareDefault({ template, serverCallbackArgs, pickerSettings, objectType: 'text' }),
   sendTextTemplateToMe: ({ template }) => createSendDefaultMe({ template, objectType: 'text' }),
-  sendTextTemplateToFriends: ({ template, receiverUuids }) =>
-    createSendDefaultFriends({ template, receiverUuids, objectType: 'text' }),
-  shareCalendarTemplate: ({ template, serverCallbackArgs }) =>
-    createShareDefault({ template, serverCallbackArgs, objectType: 'calendar' }),
+  sendTextTemplateToFriends: ({ template, receiverUuids, includeFailureInfo }) =>
+    createSendDefaultFriends({ template, receiverUuids, includeFailureInfo, objectType: 'text' }),
+  shareCalendarTemplate: ({ template, serverCallbackArgs, pickerSettings }) =>
+    createShareDefault({ template, serverCallbackArgs, pickerSettings, objectType: 'calendar' }),
   sendCalendarTemplateToMe: ({ template }) =>
     createSendDefaultMe({ template, objectType: 'calendar' }),
-  sendCalendarTemplateToFriends: ({ template, receiverUuids }) =>
-    createSendDefaultFriends({ template, receiverUuids, objectType: 'calendar' }),
+  sendCalendarTemplateToFriends: ({ template, receiverUuids, includeFailureInfo }) =>
+    createSendDefaultFriends({
+      template,
+      receiverUuids,
+      includeFailureInfo,
+      objectType: 'calendar',
+    }),
 };
+
+async function unsupportedUrlBuilder(): Promise<never> {
+  kCreateWebError({
+    code: 'Package-UnsupportedPlatform',
+    message: 'The Kakao JavaScript SDK does not provide sharing URL builders.',
+  });
+}
+
 export const {
+  isKakaoTalkSharingAvailable,
+  getShareTemplateDiagnostics,
+  makeDefaultTemplateUrl,
+  makeCustomTemplateUrl,
+  makeScrapTemplateUrl,
+  uploadImage,
+  shareScrapTemplate,
+  sendScrapTemplateToMe,
+  sendScrapTemplateToFriends,
+  scrapImage,
   sendCalendarTemplateToFriends,
   sendCalendarTemplateToMe,
   sendCommerceTemplateToFriends,

package/src/spec/NativeKakaoShare.ts

@@ -216,21 +216,107 @@ export interface KakaoCalendarTemplate {
   buttons?: KakaoTemplateButton[];
 }
 
+export type KakaoImageUploadResult = {
+  infos: {
+    original: {
+      url: string;
+      contentType: string;
+      length: Double;
+      width: Double;
+      height: Double;
+    };
+  };
+};
+
+export type KakaoMessageSendResult = {
+  successfulReceiverUuids: string[];
+  failureInfos: {
+    code: Int32;
+    msg: string;
+    receiverUuids: string[];
+  }[];
+};
+
+export type KakaoSharePickerSettings = {
+  type?: 'default' | 'friend' | 'chat';
+  limit?: number;
+};
+
+export type KakaoDefaultTemplateParams = (
+  | { templateType: 'feed'; template: KakaoFeedTemplate }
+  | { templateType: 'list'; template: KakaoListTemplate }
+  | { templateType: 'location'; template: KakaoLocationTemplate }
+  | { templateType: 'commerce'; template: KakaoCommerceTemplate }
+  | { templateType: 'text'; template: KakaoTextTemplate }
+  | { templateType: 'calendar'; template: KakaoCalendarTemplate }
+) & { serverCallbackArgs?: Readonly<Record<string, string>> };
+
+export type KakaoShareTemplateDiagnosticsParams = (
+  | KakaoDefaultTemplateParams
+  | {
+      templateType: 'custom';
+      templateId: Double;
+      templateArgs?: Readonly<Record<string, string>>;
+    }
+  | {
+      templateType: 'scrap';
+      requestUrl: string;
+      templateId?: Double;
+      templateArgs?: Readonly<Record<string, string>>;
+    }
+) & {
+  serverCallbackArgs?: Readonly<Record<string, string>>;
+  pickerSettings?: KakaoSharePickerSettings;
+};
+
+export type KakaoShareTemplateDiagnostics = {
+  warningMsg: Readonly<{ [key: string]: string }>;
+  argumentMsg: Readonly<{ [key: string]: string }>;
+};
+
 export interface Spec extends TurboModule {
+  isKakaoTalkSharingAvailable(): Promise<boolean>;
+  makeTemplateUrl(
+    templateType: string,
+    templateId: Double,
+    templateJson: UnsafeObject,
+    templateArgs: Readonly<{ [key: string]: string }>,
+    serverCallbackArgs: Readonly<{ [key: string]: string }>,
+  ): Promise<string>;
+  getTemplateDiagnostics(
+    templateType: string,
+    templateId: Double,
+    templateJson: UnsafeObject,
+    templateArgs: Readonly<{ [key: string]: string }>,
+    serverCallbackArgs: Readonly<{ [key: string]: string }>,
+    pickerSettings?: UnsafeObject,
+  ): Promise<KakaoShareTemplateDiagnostics>;
+  uploadImage(imageUri: string, secureResource: boolean): Promise<KakaoImageUploadResult>;
+  shareScrapTemplate(
+    requestUrl: string,
+    useWebBrowserIfKakaoTalkNotAvailable: boolean,
+    templateId?: Double,
+    templateArgs?: Readonly<{ [key: string]: string }>,
+    serverCallbackArgs?: Readonly<{ [key: string]: string }>,
+    pickerSettings?: UnsafeObject,
+  ): Promise<void>;
+
+  scrapImage(imageUrl: string, secureResource: boolean): Promise<KakaoImageUploadResult>;
   shareOrSendMeOrSendFriendOrWhatever(
     /* share, send-me, send-friend */
     sendType: string,
-    /* custom, feed, list, location, commerce, text, calendar */
+    /* custom, scrap, feed, list, location, commerce, text, calendar */
     templateType: string,
-    /* only for custom */
+    /* only for custom or scrap (-1 uses the default scrap template) */
     templateId: Double,
-    /* only for default templates */
+    /* default template fields or { requestUrl } for scrap */
     templateJson: UnsafeObject,
     /* only for pass friend uuid directly */
     receiverUuids: ReadonlyArray<string>,
     useWebBrowserIfKakaoTalkNotAvailable: boolean,
     templateArgs: Readonly<{ [key: string]: string }>,
     serverCallbackArgs: Readonly<{ [key: string]: string }>,
+    pickerSettings?: UnsafeObject,
   ): Promise<any>;
 }
 

package/src/validateSharePickerSettings.ts

@@ -0,0 +1,38 @@
+import { kAssert } from '@react-native-kakao/core';
+
+import type { KakaoSharePickerSettings } from './spec/NativeKakaoShare';
+
+const minSelectionLimit = 1;
+const maxSelectionLimit = 10;
+
+export function validateSharePickerSettings(pickerSettings?: KakaoSharePickerSettings) {
+  if (pickerSettings == null) {
+    return undefined;
+  }
+
+  kAssert(
+    typeof pickerSettings === 'object' && !Array.isArray(pickerSettings),
+    '[share] pickerSettings must be an object',
+  );
+
+  const { type, limit } = pickerSettings;
+  kAssert(
+    type == null || ['default', 'friend', 'chat'].includes(type),
+    '[share] pickerSettings.type must be default, friend, or chat',
+  );
+
+  kAssert(
+    limit == null ||
+      (Number.isInteger(limit) && limit >= minSelectionLimit && limit <= maxSelectionLimit),
+    `[share] pickerSettings.limit must be an integer between ${minSelectionLimit} and ${maxSelectionLimit}`,
+  );
+
+  if (type == null && limit == null) {
+    return undefined;
+  }
+
+  return {
+    ...(type != null && { type }),
+    ...(limit != null && { limit }),
+  };
+}