slackblock 0.4.0 → 1.0.0-0

package/dist/index.mjs

@@ -0,0 +1,1170 @@
+// src/utils/get-type.ts
+var getType = (element) => {
+  if (typeof element === "string") {
+    return "string";
+  }
+  if (element === null || element === void 0 || typeof element === "boolean") {
+    return "null";
+  }
+  if (Array.isArray(element)) {
+    throw new TypeError("Cannot type arrays");
+  }
+  const { type } = element;
+  if (typeof type === "string") {
+    return type;
+  }
+  const { slackType, displayName, name } = type;
+  return slackType || displayName || name || type;
+};
+var get_type_default = getType;
+
+// src/utils/validation.ts
+var warn = (message) => {
+  console.warn(message);
+};
+var warnIfTooLong = (name, value, max) => {
+  if (!value) {
+    return;
+  }
+  if (value.length > max) {
+    warn(`${name} exceeds ${max} characters.`);
+  }
+};
+var warnIfTooMany = (name, values, max) => {
+  if (!values) {
+    return;
+  }
+  if (values.length > max) {
+    warn(`${name} exceeds ${max} items.`);
+  }
+};
+
+// src/transformers/block/text.ts
+var transformText = (element) => {
+  const {
+    props: {
+      plainText,
+      children,
+      emoji,
+      verbatim
+    }
+  } = element;
+  const res = {
+    type: plainText ? "plain_text" : "mrkdwn",
+    text: children
+  };
+  if (typeof children === "string") {
+    warnIfTooLong("Text", children, 3e3);
+  }
+  if (emoji) {
+    res.emoji = true;
+  }
+  if (verbatim) {
+    res.verbatim = true;
+  }
+  return res;
+};
+var text_default = transformText;
+
+// src/transformers/block/confirmation.tsx
+import React2 from "react";
+
+// src/components/block/text.tsx
+import React from "react";
+var Text = class extends React.Component {
+};
+Text.slackType = "Text";
+
+// src/transformers/block/confirmation.tsx
+var transformConfirmation = (child) => {
+  const { title, confirm, deny, children } = child.props;
+  const res = {
+    title: transform(/* @__PURE__ */ React2.createElement(Text, { plainText: true }, title)),
+    text: transform(children),
+    confirm: transform(/* @__PURE__ */ React2.createElement(Text, { plainText: true }, confirm)),
+    deny: transform(/* @__PURE__ */ React2.createElement(Text, { plainText: true }, deny))
+  };
+  return res;
+};
+var confirmation_default = transformConfirmation;
+
+// src/transformers/block/button.tsx
+import React3 from "react";
+var transformButton = (child) => {
+  const { actionId, children, url, value, style, confirm, accessibilityLabel } = child.props;
+  warnIfTooLong("Button action_id", actionId, 255);
+  if (typeof children === "string") {
+    warnIfTooLong("Button text", children, 75);
+  }
+  warnIfTooLong("Button value", value, 2e3);
+  const res = {
+    type: "button",
+    text: transform(/* @__PURE__ */ React3.createElement(Text, { plainText: true }, children)),
+    action_id: actionId
+  };
+  if (url) {
+    res.url = url;
+  }
+  if (value) {
+    res.value = value;
+  }
+  if (style) {
+    res.style = style;
+  }
+  if (confirm) {
+    res.confirm = transform(confirm);
+  }
+  if (accessibilityLabel) {
+    res.accessibility_label = accessibilityLabel;
+  }
+  return res;
+};
+var button_default = transformButton;
+
+// src/transformers/block/image.ts
+var transformImage = (child) => {
+  const { url, alt } = child.props;
+  return {
+    type: "image",
+    image_url: url,
+    alt_text: alt
+  };
+};
+var image_default = transformImage;
+
+// src/transformers/layout/container.ts
+var normalizeChildren = (children) => {
+  const result = [];
+  const stack = Array.isArray(children) ? [...children] : [children];
+  while (stack.length > 0) {
+    const child = stack.shift();
+    if (child === null || child === void 0 || typeof child === "boolean") {
+      continue;
+    }
+    if (Array.isArray(child)) {
+      stack.unshift(...child);
+      continue;
+    }
+    result.push(child);
+  }
+  return result;
+};
+var transformContainer = (child) => {
+  const { children } = child.props;
+  const elements = normalizeChildren(children);
+  return elements.map((element) => transform(element));
+};
+var container_default = transformContainer;
+
+// src/transformers/layout/section.ts
+var transformSection = (element) => {
+  const {
+    props: {
+      text,
+      blockId,
+      children,
+      accessory
+    }
+  } = element;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = {
+    type: "section",
+    text: transform(text)
+  };
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  if (accessory) {
+    res.accessory = transform(accessory);
+  }
+  if (children) {
+    res.fields = [];
+    let fields = children;
+    if (!Array.isArray(fields)) {
+      fields = [fields];
+    }
+    for (const field of fields) {
+      if (field) {
+        const t = transform(field);
+        res.fields.push(t);
+      }
+    }
+    warnIfTooMany("Section fields", res.fields, 10);
+  }
+  return res;
+};
+var section_default = transformSection;
+
+// src/transformers/layout/actions.ts
+var transformActions = (child) => {
+  const { children, blockId } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  let elements = children;
+  if (!Array.isArray(elements)) {
+    elements = [elements];
+  }
+  const res = {
+    type: "actions",
+    elements: elements.map((element) => transform(element))
+  };
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  warnIfTooMany("Actions elements", res.elements, 25);
+  return res;
+};
+var actions_default = transformActions;
+
+// src/transformers/layout/context.ts
+var transformContext = (child) => {
+  const { children, blockId } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  let elements = children;
+  if (!Array.isArray(elements)) {
+    elements = [elements];
+  }
+  const res = {
+    type: "context",
+    elements: elements.map((element) => transform(element))
+  };
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  warnIfTooMany("Context elements", res.elements, 10);
+  return res;
+};
+var context_default = transformContext;
+
+// src/transformers/layout/divider.ts
+var transformDivider = (child) => {
+  const { blockId } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = { type: "divider" };
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  return res;
+};
+var divider_default = transformDivider;
+
+// src/transformers/layout/file.ts
+var transformFile = (child) => {
+  const { externalId, blockId } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = {
+    type: "file",
+    source: "remote",
+    external_id: externalId
+  };
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  return res;
+};
+var file_default = transformFile;
+
+// src/transformers/layout/header.tsx
+import React4 from "react";
+var transformHeader = (child) => {
+  const { text, blockId, emoji } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = {
+    type: "header",
+    text: transform(/* @__PURE__ */ React4.createElement(Text, { plainText: true, emoji }, text))
+  };
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  return res;
+};
+var header_default = transformHeader;
+
+// src/transformers/layout/image.tsx
+import React5 from "react";
+var transformImageLayout = (child) => {
+  const { url, alt, title, blockId } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = {
+    type: "image",
+    image_url: url,
+    alt_text: alt
+  };
+  if (title) {
+    res.title = transform(/* @__PURE__ */ React5.createElement(Text, { plainText: true }, title));
+  }
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  return res;
+};
+var image_default2 = transformImageLayout;
+
+// src/transformers/layout/input.tsx
+import React6 from "react";
+var transformInput = (child) => {
+  const { label, element, hint, optional, blockId } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = {
+    type: "input",
+    label: transform(/* @__PURE__ */ React6.createElement(Text, { plainText: true }, label)),
+    element: transform(element)
+  };
+  if (hint) {
+    res.hint = transform(/* @__PURE__ */ React6.createElement(Text, { plainText: true }, hint));
+  }
+  if (optional) {
+    res.optional = true;
+  }
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  return res;
+};
+var input_default = transformInput;
+
+// src/transformers/rich-text/utils.ts
+var normalizeRichTextChildren = (children) => {
+  const result = [];
+  const stack = Array.isArray(children) ? [...children] : [children];
+  while (stack.length > 0) {
+    const child = stack.shift();
+    if (child === null || child === void 0 || typeof child === "boolean") {
+      continue;
+    }
+    if (Array.isArray(child)) {
+      stack.unshift(...child);
+      continue;
+    }
+    result.push(child);
+  }
+  return result;
+};
+var toInlineElements = (children) => {
+  const items = normalizeRichTextChildren(children);
+  return items.map((item) => {
+    if (typeof item === "string") {
+      return { type: "text", text: item };
+    }
+    return transform(item);
+  });
+};
+var toBlockElements = (children) => {
+  const items = normalizeRichTextChildren(children);
+  return items.map((item) => {
+    if (typeof item === "string") {
+      return {
+        type: "rich_text_section",
+        elements: [{ type: "text", text: item }]
+      };
+    }
+    return transform(item);
+  });
+};
+
+// src/transformers/layout/rich-text.ts
+var transformRichText = (child) => {
+  const { elements, children, blockId } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = {
+    type: "rich_text",
+    elements: elements != null ? elements : toBlockElements(children)
+  };
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  return res;
+};
+var rich_text_default = transformRichText;
+
+// src/transformers/layout/video.tsx
+import React7 from "react";
+var transformVideo = (child) => {
+  const {
+    title,
+    videoUrl,
+    thumbnailUrl,
+    altText,
+    titleUrl,
+    description,
+    authorName,
+    providerName,
+    providerIconUrl,
+    blockId
+  } = child.props;
+  warnIfTooLong("block_id", blockId, 255);
+  const res = {
+    type: "video",
+    title: transform(/* @__PURE__ */ React7.createElement(Text, { plainText: true }, title)),
+    video_url: videoUrl,
+    thumbnail_url: thumbnailUrl,
+    alt_text: altText
+  };
+  if (titleUrl) {
+    res.title_url = titleUrl;
+  }
+  if (description) {
+    res.description = transform(/* @__PURE__ */ React7.createElement(Text, { plainText: true }, description));
+  }
+  if (authorName) {
+    res.author_name = authorName;
+  }
+  if (providerName) {
+    res.provider_name = providerName;
+  }
+  if (providerIconUrl) {
+    res.provider_icon_url = providerIconUrl;
+  }
+  if (blockId) {
+    res.block_id = blockId;
+  }
+  return res;
+};
+var video_default = transformVideo;
+
+// src/transformers/input/text.tsx
+import React8 from "react";
+var transformTextInput = (child) => {
+  const {
+    actionId,
+    placeholder,
+    initial,
+    multiline,
+    minLength,
+    maxLength,
+    focusOnLoad,
+    dispatchActionConfig
+  } = child.props;
+  warnIfTooLong("TextInput action_id", actionId, 255);
+  if (placeholder) {
+    warnIfTooLong("TextInput placeholder", placeholder, 150);
+  }
+  const res = {
+    type: "plain_text_input",
+    action_id: actionId
+  };
+  if (placeholder) {
+    res.placeholder = transform(/* @__PURE__ */ React8.createElement(Text, { plainText: true }, placeholder));
+  }
+  if (initial) {
+    res.initial_value = initial;
+  }
+  if (multiline) {
+    res.multiline = true;
+  }
+  if (minLength) {
+    res.min_length = minLength;
+  }
+  if (maxLength) {
+    res.max_length = maxLength;
+  }
+  if (focusOnLoad !== void 0) {
+    res.focus_on_load = focusOnLoad;
+  }
+  if (dispatchActionConfig && dispatchActionConfig.triggerActionsOn.length > 0) {
+    res.dispatch_action_config = {
+      trigger_actions_on: dispatchActionConfig.triggerActionsOn
+    };
+  }
+  return res;
+};
+var text_default2 = transformTextInput;
+
+// src/transformers/input/date-time-picker.ts
+var transformDateTimePicker = (child) => {
+  const { actionId, initialDateTime, confirm, focusOnLoad } = child.props;
+  warnIfTooLong("DateTimePicker action_id", actionId, 255);
+  const res = {
+    type: "datetimepicker",
+    action_id: actionId
+  };
+  if (initialDateTime !== void 0) {
+    if (!Number.isInteger(initialDateTime)) {
+      throw new TypeError("DateTime must be a unix timestamp in seconds.");
+    }
+    res.initial_date_time = initialDateTime;
+  }
+  if (confirm) {
+    res.confirm = transform(confirm);
+  }
+  if (focusOnLoad !== void 0) {
+    res.focus_on_load = focusOnLoad;
+  }
+  return res;
+};
+var date_time_picker_default = transformDateTimePicker;
+
+// src/transformers/input/date-picker.tsx
+import React9 from "react";
+var isValidDateString = (value) => {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) {
+    return false;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (month < 1 || month > 12) {
+    return false;
+  }
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+};
+var transformDatePicker = (child) => {
+  const { actionId, placeholder, initialDate, confirm, focusOnLoad } = child.props;
+  warnIfTooLong("DatePicker action_id", actionId, 255);
+  if (placeholder) {
+    warnIfTooLong("DatePicker placeholder", placeholder, 150);
+  }
+  const res = {
+    type: "datepicker",
+    action_id: actionId
+  };
+  if (placeholder) {
+    res.placeholder = transform(/* @__PURE__ */ React9.createElement(Text, { plainText: true }, placeholder));
+  }
+  if (initialDate) {
+    if (!isValidDateString(initialDate)) {
+      throw new Error("Date must be valid and in format YYYY-MM-DD.");
+    }
+    res.initial_date = initialDate;
+  }
+  if (confirm) {
+    res.confirm = transform(confirm);
+  }
+  if (focusOnLoad !== void 0) {
+    res.focus_on_load = focusOnLoad;
+  }
+  return res;
+};
+var date_picker_default = transformDatePicker;
+
+// src/transformers/input/checkboxes.ts
+var transformCheckboxes = (child) => {
+  const { actionId, children, initialOptions, confirm, focusOnLoad } = child.props;
+  warnIfTooLong("Checkboxes action_id", actionId, 255);
+  let elements = children;
+  if (!Array.isArray(elements)) {
+    elements = [elements];
+  }
+  const res = {
+    type: "checkboxes",
+    action_id: actionId,
+    options: elements.map((element) => transform(element))
+  };
+  if (initialOptions && initialOptions.length > 0) {
+    res.initial_options = initialOptions.map((option) => transform(option));
+  }
+  if (confirm) {
+    res.confirm = transform(confirm);
+  }
+  if (focusOnLoad !== void 0) {
+    res.focus_on_load = focusOnLoad;
+  }
+  return res;
+};
+var checkboxes_default = transformCheckboxes;
+
+// src/transformers/input/select.tsx
+import React11 from "react";
+
+// src/components/input/select.tsx
+import React10 from "react";
+var selectTypes = {
+  STATIC: "static",
+  EXTERNAL: "external",
+  USER: "user",
+  CONVERSATION: "conversation",
+  CHANNEL: "channel"
+};
+var Select = class extends React10.Component {
+};
+Select.slackType = "Select";
+
+// src/transformers/input/select.tsx
+var OPTION = "Option";
+var OPTION_GROUP = "OptionGroup";
+var types = {
+  [selectTypes.STATIC]: "static_select",
+  [selectTypes.EXTERNAL]: "external_select",
+  [selectTypes.USER]: "users_select",
+  [selectTypes.CONVERSATION]: "conversations_select",
+  [selectTypes.CHANNEL]: "channels_select"
+};
+var MULTI_PREFIX = "multi_";
+var normalizeElements = (elements) => {
+  if (!elements) {
+    return [];
+  }
+  return Array.isArray(elements) ? elements : [elements];
+};
+var assignStaticOptions = (elements, result) => {
+  const elementType = get_type_default(elements[0]);
+  if (elements.some((element) => get_type_default(element) !== elementType)) {
+    if (elementType === OPTION && elements.some((element) => get_type_default(element) !== OPTION_GROUP)) {
+      throw new TypeError("You cannot mix OptionGroup types with Option types in a Select block.");
+    } else if (elementType === OPTION_GROUP && elements.some((element) => get_type_default(element) !== OPTION)) {
+      throw new TypeError("You cannot mix OptionGroup types with Option types in a Select block.");
+    }
+    throw new TypeError("Only allowed types are Option OR OptionGroup");
+  }
+  if (elementType === OPTION) {
+    const options = elements;
+    result.options = options.map((element) => transform(element));
+  } else if (elementType === OPTION_GROUP) {
+    const optionGroups = elements;
+    result.option_groups = optionGroups.map((element) => transform(element));
+  }
+};
+var applyInitialSelections = (type, isMulti, result, initialValues) => {
+  const { initialOptions, initialUsers, initialConversations, initialChannels } = initialValues;
+  switch (type) {
+    case selectTypes.USER: {
+      if (initialUsers && initialUsers.length > 0) {
+        if (isMulti) {
+          result.initial_users = initialUsers;
+        } else {
+          result.initial_user = initialUsers[0];
+        }
+      }
+      break;
+    }
+    case selectTypes.CONVERSATION: {
+      if (initialConversations && initialConversations.length > 0) {
+        if (isMulti) {
+          result.initial_conversations = initialConversations;
+        } else {
+          result.initial_conversation = initialConversations[0];
+        }
+      }
+      break;
+    }
+    case selectTypes.CHANNEL: {
+      if (initialChannels && initialChannels.length > 0) {
+        if (isMulti) {
+          result.initial_channels = initialChannels;
+        } else {
+          result.initial_channel = initialChannels[0];
+        }
+      }
+      break;
+    }
+    case selectTypes.STATIC:
+    case selectTypes.EXTERNAL: {
+      if (initialOptions && initialOptions.length > 0) {
+        const transformedOptions = initialOptions.map((element) => transform(element));
+        if (isMulti) {
+          result.initial_options = transformedOptions;
+        } else {
+          result.initial_option = transformedOptions[0];
+        }
+      }
+      break;
+    }
+  }
+};
+var transformSelect = (child) => {
+  const {
+    placeholder,
+    actionId,
+    multi,
+    children,
+    initialOptions,
+    confirm,
+    maxSelectedItems,
+    type: typeProperty,
+    initialUsers,
+    initialConversations,
+    initialChannels,
+    minQueryLength,
+    focusOnLoad,
+    defaultToCurrentConversation,
+    responseUrlEnabled,
+    filter
+  } = child.props;
+  const type = typeProperty != null ? typeProperty : selectTypes.STATIC;
+  const typeString = `${multi ? MULTI_PREFIX : ""}${types[type]}`;
+  warnIfTooLong("Select action_id", actionId, 255);
+  warnIfTooLong("Select placeholder", placeholder, 150);
+  const result = {
+    type: typeString,
+    placeholder: transform(/* @__PURE__ */ React11.createElement(Text, { plainText: true }, placeholder)),
+    action_id: actionId
+  };
+  const elements = normalizeElements(children);
+  if (type === selectTypes.STATIC) {
+    assignStaticOptions(elements, result);
+  }
+  if (confirm) {
+    result.confirm = transform(confirm);
+  }
+  applyInitialSelections(type, Boolean(multi), result, {
+    initialOptions,
+    initialUsers,
+    initialConversations,
+    initialChannels
+  });
+  if (maxSelectedItems) {
+    result.max_selected_items = maxSelectedItems;
+  }
+  if (focusOnLoad !== void 0) {
+    result.focus_on_load = focusOnLoad;
+  }
+  if (type === selectTypes.EXTERNAL && minQueryLength !== void 0) {
+    result.min_query_length = minQueryLength;
+  }
+  if (type === selectTypes.CONVERSATION) {
+    if (defaultToCurrentConversation !== void 0) {
+      result.default_to_current_conversation = defaultToCurrentConversation;
+    }
+    if (responseUrlEnabled !== void 0) {
+      result.response_url_enabled = responseUrlEnabled;
+    }
+    if (filter) {
+      const filterValue = {};
+      if (filter.include && filter.include.length > 0) {
+        filterValue.include = filter.include;
+      }
+      if (filter.excludeExternalSharedChannels !== void 0) {
+        filterValue.exclude_external_shared_channels = filter.excludeExternalSharedChannels;
+      }
+      if (filter.excludeBotUsers !== void 0) {
+        filterValue.exclude_bot_users = filter.excludeBotUsers;
+      }
+      if (Object.keys(filterValue).length > 0) {
+        result.filter = filterValue;
+      }
+    }
+  }
+  return result;
+};
+var select_default = transformSelect;
+
+// src/transformers/input/option.tsx
+import React12 from "react";
+var transformOption = (child) => {
+  const { children: text, value, url, description } = child.props;
+  warnIfTooLong("Option text", text, 75);
+  warnIfTooLong("Option value", value, 75);
+  warnIfTooLong("Option description", description, 75);
+  const res = {
+    text: transform(/* @__PURE__ */ React12.createElement(Text, { plainText: true }, text)),
+    value
+  };
+  if (description) {
+    res.description = transform(/* @__PURE__ */ React12.createElement(Text, { plainText: true }, description));
+  }
+  if (url) {
+    res.url = url;
+  }
+  return res;
+};
+var option_default = transformOption;
+
+// src/transformers/input/option-group.tsx
+import React13 from "react";
+var transformOptionGroup = (child) => {
+  const { label, children } = child.props;
+  warnIfTooLong("OptionGroup label", label, 75);
+  let options = children;
+  if (!Array.isArray(options)) {
+    options = [options];
+  }
+  return {
+    label: transform(/* @__PURE__ */ React13.createElement(Text, { plainText: true }, label)),
+    options: options.map((option) => transform(option))
+  };
+};
+var option_group_default = transformOptionGroup;
+
+// src/transformers/input/overflow.ts
+var transformOverflow = (child) => {
+  const { actionId, children, confirm } = child.props;
+  warnIfTooLong("Overflow action_id", actionId, 255);
+  let elements = children;
+  if (!Array.isArray(elements)) {
+    elements = [elements];
+  }
+  const res = {
+    type: "overflow",
+    action_id: actionId,
+    options: elements.map((element) => transform(element))
+  };
+  if (confirm) {
+    res.confirm = transform(confirm);
+  }
+  return res;
+};
+var overflow_default = transformOverflow;
+
+// src/transformers/input/radio-group.ts
+var transformRadioGroup = (child) => {
+  const { actionId, children, initialOption, confirm, focusOnLoad } = child.props;
+  warnIfTooLong("RadioGroup action_id", actionId, 255);
+  let elements = children;
+  if (!Array.isArray(elements)) {
+    elements = [elements];
+  }
+  const res = {
+    type: "radio_buttons",
+    action_id: actionId,
+    options: elements.map((element) => transform(element))
+  };
+  if (initialOption) {
+    res.initial_option = transform(initialOption);
+  }
+  if (confirm) {
+    res.confirm = transform(confirm);
+  }
+  if (focusOnLoad !== void 0) {
+    res.focus_on_load = focusOnLoad;
+  }
+  return res;
+};
+var radio_group_default = transformRadioGroup;
+
+// src/transformers/input/time-picker.tsx
+import React14 from "react";
+var isValidTimeString = (value) => {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!match) {
+    return false;
+  }
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  return hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59;
+};
+var transformTimePicker = (child) => {
+  const { actionId, placeholder, initialTime, confirm, focusOnLoad } = child.props;
+  warnIfTooLong("TimePicker action_id", actionId, 255);
+  if (placeholder) {
+    warnIfTooLong("TimePicker placeholder", placeholder, 150);
+  }
+  const res = {
+    type: "timepicker",
+    action_id: actionId
+  };
+  if (placeholder) {
+    res.placeholder = transform(/* @__PURE__ */ React14.createElement(Text, { plainText: true }, placeholder));
+  }
+  if (initialTime) {
+    if (!isValidTimeString(initialTime)) {
+      throw new Error("Time must be valid and in format HH:MM.");
+    }
+    res.initial_time = initialTime;
+  }
+  if (confirm) {
+    res.confirm = transform(confirm);
+  }
+  if (focusOnLoad !== void 0) {
+    res.focus_on_load = focusOnLoad;
+  }
+  return res;
+};
+var time_picker_default = transformTimePicker;
+
+// src/transformers/rich-text/section.ts
+var transformRichTextSection = (child) => {
+  const { children } = child.props;
+  return {
+    type: "rich_text_section",
+    elements: toInlineElements(children)
+  };
+};
+var section_default2 = transformRichTextSection;
+
+// src/transformers/rich-text/list.ts
+var transformRichTextList = (child) => {
+  const { style, children, indent, border } = child.props;
+  const res = {
+    type: "rich_text_list",
+    style,
+    elements: toBlockElements(children)
+  };
+  if (indent !== void 0) {
+    res.indent = indent;
+  }
+  if (border !== void 0) {
+    res.border = border;
+  }
+  return res;
+};
+var list_default = transformRichTextList;
+
+// src/transformers/rich-text/quote.ts
+var transformRichTextQuote = (child) => {
+  const { children } = child.props;
+  return {
+    type: "rich_text_quote",
+    elements: toInlineElements(children)
+  };
+};
+var quote_default = transformRichTextQuote;
+
+// src/transformers/rich-text/preformatted.ts
+var transformRichTextPreformatted = (child) => {
+  const { children } = child.props;
+  return {
+    type: "rich_text_preformatted",
+    elements: toInlineElements(children)
+  };
+};
+var preformatted_default = transformRichTextPreformatted;
+
+// src/transformers/rich-text/text.ts
+var transformRichTextText = (child) => {
+  const { children, style } = child.props;
+  const res = {
+    type: "text",
+    text: children
+  };
+  if (style) {
+    res.style = style;
+  }
+  return res;
+};
+var text_default3 = transformRichTextText;
+
+// src/transformers/rich-text/link.ts
+var transformRichTextLink = (child) => {
+  const { url, children, style } = child.props;
+  const res = {
+    type: "link",
+    url
+  };
+  if (children) {
+    res.text = children;
+  }
+  if (style) {
+    res.style = style;
+  }
+  return res;
+};
+var link_default = transformRichTextLink;
+
+// src/transformers/rich-text/user.ts
+var transformRichTextUser = (child) => {
+  const { userId } = child.props;
+  return {
+    type: "user",
+    user_id: userId
+  };
+};
+var user_default = transformRichTextUser;
+
+// src/transformers/rich-text/channel.ts
+var transformRichTextChannel = (child) => {
+  const { channelId } = child.props;
+  return {
+    type: "channel",
+    channel_id: channelId
+  };
+};
+var channel_default = transformRichTextChannel;
+
+// src/transformers/rich-text/emoji.ts
+var transformRichTextEmoji = (child) => {
+  const { name } = child.props;
+  return {
+    type: "emoji",
+    name
+  };
+};
+var emoji_default = transformRichTextEmoji;
+
+// src/transformers/rich-text/date.ts
+var transformRichTextDate = (child) => {
+  const { timestamp, format, fallback, link } = child.props;
+  const res = {
+    type: "date",
+    timestamp,
+    format,
+    fallback
+  };
+  if (link) {
+    res.link = link;
+  }
+  return res;
+};
+var date_default = transformRichTextDate;
+
+// src/transformers/rich-text/broadcast.ts
+var transformRichTextBroadcast = (child) => {
+  const { range } = child.props;
+  return {
+    type: "broadcast",
+    range
+  };
+};
+var broadcast_default = transformRichTextBroadcast;
+
+// src/transformers/rich-text/user-group.ts
+var transformRichTextUserGroup = (child) => {
+  const { usergroupId } = child.props;
+  return {
+    type: "usergroup",
+    usergroup_id: usergroupId
+  };
+};
+var user_group_default = transformRichTextUserGroup;
+
+// src/transformers/index.ts
+var Transformers = {
+  Container: container_default,
+  Section: section_default,
+  Actions: actions_default,
+  Context: context_default,
+  Divider: divider_default,
+  File: file_default,
+  Header: header_default,
+  ImageLayout: image_default2,
+  Input: input_default,
+  RichText: rich_text_default,
+  Video: video_default,
+  Text: text_default,
+  Confirmation: confirmation_default,
+  Button: button_default,
+  Image: image_default,
+  TextInput: text_default2,
+  DateTimePicker: date_time_picker_default,
+  DatePicker: date_picker_default,
+  Checkboxes: checkboxes_default,
+  Select: select_default,
+  Overflow: overflow_default,
+  RadioGroup: radio_group_default,
+  TimePicker: time_picker_default,
+  Option: option_default,
+  OptionGroup: option_group_default,
+  RichTextSection: section_default2,
+  RichTextList: list_default,
+  RichTextQuote: quote_default,
+  RichTextPreformatted: preformatted_default,
+  RichTextText: text_default3,
+  RichTextLink: link_default,
+  RichTextUser: user_default,
+  RichTextChannel: channel_default,
+  RichTextEmoji: emoji_default,
+  RichTextDate: date_default,
+  RichTextBroadcast: broadcast_default,
+  RichTextUserGroup: user_group_default
+};
+var transformers_default = Transformers;
+var transform = (element) => {
+  const type = get_type_default(element);
+  if (!Transformers[type]) {
+    throw new Error(`No transformer exists for type '${type}'`);
+  }
+  return Transformers[type](element);
+};
+
+// src/parser/index.ts
+var normalizeChildren2 = (children) => {
+  const result = [];
+  const stack = Array.isArray(children) ? [...children] : [children];
+  while (stack.length > 0) {
+    const child = stack.shift();
+    if (child === null || child === void 0 || typeof child === "boolean") {
+      continue;
+    }
+    if (Array.isArray(child)) {
+      stack.unshift(...child);
+      continue;
+    }
+    result.push(child);
+  }
+  return result;
+};
+var appendTransformed = (value, blocks) => {
+  if (value === null || value === void 0 || typeof value === "boolean") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      appendTransformed(item, blocks);
+    }
+    return;
+  }
+  blocks.push(value);
+};
+var parseChildren = (children) => {
+  if (typeof children === "string") {
+    return { text: children };
+  }
+  const normalizedChildren = normalizeChildren2(children);
+  const transformedBlocks = [];
+  for (const child of normalizedChildren) {
+    const type = get_type_default(child);
+    const transformer = transformers_default[type];
+    if (transformer) {
+      appendTransformed(transformer(child), transformedBlocks);
+    } else if (type !== "null") {
+      console.warn(`No transformer for child type '${type}' exists and will be ignored.`);
+    }
+  }
+  if (transformedBlocks.length === 0) {
+    return {};
+  }
+  return { blocks: transformedBlocks };
+};
+var parser_default = parseChildren;
+
+// src/renderer/index.ts
+var render = (element) => {
+  const { props: properties = {} } = element || {};
+  const typeName = get_type_default(element);
+  if (typeName !== "Message") {
+    throw new TypeError("Provided top-level element must be a Message type.");
+  }
+  if (!properties.children) {
+    throw new Error("Cannot render a Message with no children.");
+  }
+  const json = { ...parser_default(properties.children) };
+  if (properties.replyTo) {
+    json.thread_ts = properties.replyTo;
+  }
+  if (properties.markdown !== void 0) {
+    json.mrkdwn = properties.markdown;
+  }
+  json.text = properties.text || "";
+  if (properties.iconEmoji) {
+    json.icon_emoji = properties.iconEmoji;
+  }
+  if (properties.iconUrl) {
+    json.icon_url = properties.iconUrl;
+  }
+  if (properties.parse) {
+    json.parse = properties.parse;
+  }
+  if (properties.username) {
+    json.username = properties.username;
+  }
+  if (properties.asUser) {
+    json.as_user = properties.asUser;
+  }
+  if (properties.replyBroadcast) {
+    json.reply_broadcast = properties.replyBroadcast;
+  }
+  if (properties.unfurlLinks) {
+    json.unfurl_links = properties.unfurlLinks;
+  }
+  if (properties.unfurlMedia !== void 0) {
+    json.unfurl_media = properties.unfurlMedia;
+  }
+  if (properties.color && json.blocks) {
+    json.attachments = [
+      {
+        color: properties.color,
+        blocks: json.blocks
+      }
+    ];
+    delete json.blocks;
+  }
+  if (json.blocks) {
+    warnIfTooMany("Message blocks", json.blocks, 50);
+  }
+  return json;
+};
+var renderer_default = render;
+export {
+  renderer_default as default
+};
+//# sourceMappingURL=index.mjs.map