slackblock 0.4.0 → 1.0.0-0

package/src/transformers/input/overflow.ts

@@ -1,33 +0,0 @@
-import {Element} from '../../constants/types';
-import {Props as OverflowProps} from '../../components/input/overflow';
-import {ConfirmationType} from '../block/confirmation';
-import {OptionType} from './option';
-import {transform} from '..';
-
-export type OverflowType = {
-  type: 'overflow';
-  action_id: string;
-  options: OptionType[];
-  confirm?: ConfirmationType;
-};
-
-export default (child: Element): OverflowType => {
-  const {actionId, children, confirm}: OverflowProps = child.props;
-
-  let elements = children;
-  if (!Array.isArray(elements)) {
-    elements = [elements];
-  }
-
-  const res: OverflowType = {
-    type: 'overflow',
-    action_id: actionId,
-    options: elements.map(element => transform(element as Element)) as OptionType[]
-  };
-
-  if (confirm) {
-    res.confirm = transform(confirm as Element) as ConfirmationType;
-  }
-
-  return res;
-};

package/src/transformers/input/radio-group.ts

@@ -1,38 +0,0 @@
-import {Element} from '../../constants/types';
-import {Props as RadioGroupProps} from '../../components/input/radio-group';
-import {ConfirmationType} from '../block/confirmation';
-import {OptionType} from './option';
-import {transform} from '..';
-
-export type RadioGroupType = {
-  type: 'radio_buttons';
-  action_id: string;
-  options: OptionType[];
-  initial_option?: OptionType;
-  confirm?: ConfirmationType;
-};
-
-export default (child: Element): RadioGroupType => {
-  const {actionId, children, initialOption, confirm}: RadioGroupProps = child.props;
-
-  let elements = children;
-  if (!Array.isArray(elements)) {
-    elements = [elements];
-  }
-
-  const res: RadioGroupType = {
-    type: 'radio_buttons',
-    action_id: actionId,
-    options: elements.map(element => transform(element as Element)) as OptionType[]
-  };
-
-  if (initialOption) {
-    res.initial_option = transform(initialOption as Element) as OptionType;
-  }
-
-  if (confirm) {
-    res.confirm = transform(confirm as Element) as ConfirmationType;
-  }
-
-  return res;
-};

package/src/transformers/input/select.tsx

@@ -1,136 +0,0 @@
-import React from 'react';
-import {Element} from '../../constants/types';
-import {TextType} from '../block/text';
-import {OptionType} from './option';
-import {OptionGroupType} from './option-group';
-import {ConfirmationType} from '../block/confirmation';
-import {Props as SelectProps, selectTypes} from '../../components/input/select';
-import Option from '../../components/input/option';
-import Text from '../../components/block/text';
-import {transform} from '..';
-import getType from '../../utils/get-type';
-import OptionGroup from '../../components/input/option-group';
-
-type ValidSelectType =
-  'static_select' |
-  'multi_static_select' |
-  'external_select' |
-  'multi_external_select' |
-  'users_select' |
-  'multi_users_select' |
-  'conversations_select' |
-  'multi_conversations_select' |
-  'channels_select' |
-  'multi_channels_select';
-
-export type SelectType = {
-  type: ValidSelectType;
-  placeholder: TextType;
-  action_id: string;
-  options?: OptionType[];
-  option_groups?: OptionGroupType[];
-  initial_options?: OptionType[];
-  confirm?: ConfirmationType;
-  max_selected_items?: number;
-  initial_users?: string[];
-  initial_conversations?: string[];
-  initial_channels?: string[];
-};
-
-const OPTION = 'Option';
-const OPTION_GROUP = 'OptionGroup';
-
-const types = {
-  [selectTypes.STATIC]: 'static_select',
-  [selectTypes.EXTERNAL]: 'external_select',
-  [selectTypes.USER]: 'users_select',
-  [selectTypes.CONVERSATION]: 'conversations_select',
-  [selectTypes.CHANNEL]: 'channels_select'
-};
-const MULTI_PREFIX = 'multi_';
-
-export default (child: Element): SelectType => {
-  const {
-    placeholder,
-    actionId,
-    multi,
-    children,
-    initialOptions,
-    confirm,
-    maxSelectedItems,
-    type: typeProp,
-    initialUsers,
-    initialConversations,
-    initialChannels
-  }: SelectProps = child.props;
-
-  const type = typeProp || selectTypes.STATIC;
-  const typeString = `${multi ? MULTI_PREFIX : ''}${types[type]}` as ValidSelectType;
-
-  const res: SelectType = {
-    type: typeString,
-    placeholder: transform(<Text plainText>{placeholder}</Text>) as TextType,
-    action_id: actionId
-  };
-
-  let elements = children;
-  if (!Array.isArray(elements)) {
-    elements = [elements] as React.ReactElement[];
-  }
-
-  if (type === selectTypes.STATIC) {
-    const type = getType(elements[0] as Element);
-    if (elements.some((element: React.ReactElement) => getType(element as Element) !== type)) {
-      if (type === OPTION && elements.some((element: React.ReactElement) => getType(element as Element) !== OPTION_GROUP)) {
-        throw new TypeError('You cannot mix OptionGroup types with Option types in a Select block.');
-      } else if (type === OPTION_GROUP && elements.some((element: React.ReactElement) => getType(element as 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 (type === OPTION) {
-      elements = elements as React.ReactElement<Option>[];
-
-      res.options = elements.map(element => transform(element as Element)) as OptionType[];
-    } else if (type === OPTION_GROUP) {
-      elements = elements as React.ReactElement<OptionGroup>[];
-
-      res.option_groups = elements.map(element => transform(element as Element)) as OptionGroupType[];
-    }
-  }
-
-  if (confirm) {
-    res.confirm = transform(confirm as Element) as ConfirmationType;
-  }
-
-  if (type !== selectTypes.USER && initialOptions) {
-  }
-
-  switch (type) {
-    case selectTypes.USER:
-      if (initialUsers) {
-        res.initial_users = initialUsers;
-      }
-      break;
-    case selectTypes.CONVERSATION:
-      if (initialConversations) {
-        res.initial_conversations = initialConversations;
-      }
-      break;
-    case selectTypes.CHANNEL:
-      if (initialChannels) {
-        res.initial_channels = initialChannels;
-      }
-    default:
-      if (initialOptions) {
-        res.initial_options = initialOptions.map(element => transform(element as Element)) as OptionType[];
-      }
-  }
-
-  if (maxSelectedItems) {
-    res.max_selected_items = maxSelectedItems;
-  }
-
-  return res;
-};

package/src/transformers/input/text.tsx

@@ -1,47 +0,0 @@
-import React from 'react';
-import Text from '../../components/block/text';
-import {Props as TextInputProps} from '../../components/input/text';
-import {TextType as TextProps} from '../block/text';
-import {Element} from '../../constants/types';
-import { transform } from '..';
-
-export type TextType = {
-  type: 'plain_text_input';
-  action_id: string;
-  placeholder?: TextProps;
-  initial_value?: string;
-  multiline?: boolean;
-  min_length?: number;
-  max_length?: number;
-};
-
-export default (child: Element): TextType => {
-  const {actionId, placeholder, initial, multiline, minLength, maxLength}: TextInputProps = child.props;
-
-  const res: TextType = {
-    type: 'plain_text_input',
-    action_id: actionId
-  };
-
-  if (placeholder) {
-    res.placeholder = transform(<Text plainText>{placeholder}</Text>) as TextProps;
-  }
-
-  if (initial) {
-    res.initial_value = initial;
-  }
-
-  if (multiline) {
-    res.multiline = true;
-  }
-
-  if (minLength) {
-    res.min_length = minLength;
-  }
-
-  if (maxLength) {
-    res.max_length = maxLength;
-  }
-
-  return res;
-};

package/src/transformers/layout/actions.ts

@@ -1,29 +0,0 @@
-import {Element, SerializedInteractiveBlockElement, InteractiveBlockElement} from '../../constants/types';
-import {Props as ActionProps} from '../../components/layout/actions';
-import {transform} from '..';
-
-type ActionType = {
-  type: 'actions';
-  elements: SerializedInteractiveBlockElement[];
-  block_id?: string;
-};
-
-export default (child: Element): ActionType => {
-  const {children, blockId}: ActionProps = child.props;
-
-  let elements = children;
-  if (!Array.isArray(elements)) {
-    elements = [elements] as InteractiveBlockElement[];
-  }
-
-  const res: ActionType = {
-    type: 'actions',
-    elements: elements.map(element => transform(element as Element) as SerializedInteractiveBlockElement)
-  };
-
-  if (blockId) {
-    res.block_id = blockId;
-  }
-
-  return res;
-};

package/src/transformers/layout/container.ts

@@ -1,16 +0,0 @@
-import {Props as ContainerProps} from '../../components/layout/container';
-import {Element, Child} from '../../constants/types';
-import {transform} from '..';
-
-type ContainerType = Child[];
-
-export default (child: Element): ContainerType => {
-  const {children}: ContainerProps = child.props;
-
-  let elements = children;
-  if (!Array.isArray(elements)) {
-    elements = [elements] as Child[];
-  }
-
-  return (elements as Element[]).map(element => transform(element)) as Child[];
-};

package/src/transformers/layout/context.ts

@@ -1,35 +0,0 @@
-import {Element} from '../../constants/types';
-
-import {Props as ContextProps, ImageOrText as ImageOrTextElem} from '../../components/layout/context';
-import {TextType} from '../block/text';
-import {ImageType} from '../block/image';
-import {transform} from '..';
-
-type ImageOrText = ImageType | TextType;
-type ImageOrTextElemSet = ImageOrTextElem | ImageOrTextElem[];
-
-type ContextType = {
-  type: 'context';
-  elements: ImageOrText | ImageOrText[];
-  block_id?: string;
-};
-
-export default (child: Element): ContextType => {
-  const {children, blockId}: ContextProps = child.props;
-
-  let elements = children as ImageOrTextElemSet;
-  if (!Array.isArray(elements)) {
-    elements = [elements] as ImageOrTextElem[];
-  }
-
-  const res: ContextType = {
-    type: 'context',
-    elements: elements.map(element => transform(element as Element) as ImageOrText)
-  };
-
-  if (blockId) {
-    res.block_id = blockId;
-  }
-
-  return res;
-};

package/src/transformers/layout/divider.ts

@@ -1,20 +0,0 @@
-import {Element} from '../../constants/types';
-
-import {Props as DividerProps} from '../../components/layout/divider';
-
-type DividerType = {
-  type: 'divider';
-  block_id?: string;
-};
-
-export default (child: Element): DividerType => {
-  const {blockId}: DividerProps = child.props;
-
-  const res: DividerType = {type: 'divider'};
-
-  if (blockId) {
-    res.block_id = blockId;
-  }
-
-  return res;
-};

package/src/transformers/layout/file.ts

@@ -1,24 +0,0 @@
-import {Element} from '../../constants/types';
-import {Props as FileProps} from '../../components/layout/file';
-
-type FileType = {
-  type: 'file';
-  source: 'remote';
-  external_id: string;
-  block_id?: string;
-};
-
-export default (child: Element): FileType => {
-  const {externalId, blockId}: FileProps = child.props;
-  const res: FileType = {
-    type: 'file',
-    source: 'remote',
-    external_id: externalId
-  };
-
-  if (blockId) {
-    res.block_id = blockId;
-  }
-
-  return res;
-};

package/src/transformers/layout/image.tsx

@@ -1,34 +0,0 @@
-import React from 'react';
-import {Element} from '../../constants/types';
-import {TextType} from '../block/text';
-import {Props as ImageProps} from '../../components/layout/image';
-import { transform } from '..';
-import Text from '../../components/block/text';
-
-type ImageType = {
-  type: 'image';
-  image_url: string;
-  alt_text: string;
-  title?: TextType;
-  block_id?: string;
-};
-
-export default (child: Element): ImageType => {
-  const {url, alt, title, blockId}: ImageProps = child.props;
-
-  const res: ImageType = {
-    type: 'image',
-    image_url: url,
-    alt_text: alt
-  };
-
-  if (title) {
-    res.title = transform(<Text plainText>{title}</Text>) as TextType;
-  }
-
-  if (blockId) {
-    res.block_id = blockId;
-  }
-
-  return res;
-};

package/src/transformers/layout/input.tsx

@@ -1,39 +0,0 @@
-import React from 'react';
-import {Element, SerializedInputBlockElement} from '../../constants/types';
-import {TextType} from '../block/text';
-import {Props as InputProps} from '../../components/layout/input';
-import {transform} from '..';
-import Text from '../../components/block/text';
-
-type InputType = {
-  type: 'input';
-  label: TextType;
-  element: SerializedInputBlockElement;
-  hint?: TextType;
-  optional?: boolean;
-  block_id?: string;
-}
-
-export default (child: Element): InputType => {
-  const {label, element, hint, optional, blockId}: InputProps = child.props;
-
-  const res: InputType = {
-    type: 'input',
-    label: transform(<Text plainText>{label}</Text>) as TextType,
-    element: transform(element as Element) as SerializedInputBlockElement
-  };
-
-  if (hint) {
-    res.hint = transform(<Text plainText>{hint}</Text>) as TextType;
-  }
-
-  if (optional) {
-    res.optional = true;
-  }
-
-  if (blockId) {
-    res.block_id = blockId;
-  }
-
-  return res;
-};

package/src/transformers/layout/section.ts

@@ -1,53 +0,0 @@
-import {Element, SerializedBlockElement} from '../../constants/types';
-import {TextType as Text} from '../block/text';
-import TextComponent from '../../components/block/text';
-import {transform} from '..';
-
-type SectionType = {
-  type: 'section';
-  text: Text;
-  block_id?: string;
-  fields?: Text[];
-  accessory?: SerializedBlockElement;
-};
-
-export default (elem: Element): SectionType => {
-  const {
-    props: {
-      text,
-      blockId,
-      children,
-      accessory
-    }
-  } = elem;
-
-  const res: SectionType = {
-    type: 'section',
-    text: transform(text as Element) as Text
-  };
-
-  if (blockId) {
-    res.block_id = blockId;
-  }
-
-  if (accessory) {
-    res.accessory = transform(accessory) as SerializedBlockElement;
-  }
-
-  if (children) {
-    res.fields = [];
-    let fields = children;
-    if (!Array.isArray(fields)) {
-      fields = [fields];
-    }
-
-    for (const field of fields) {
-      if (field) {
-        const t = transform(field as TextComponent);
-        res.fields.push(t as Text);
-      }
-    }
-  }
-
-  return res;
-};

package/src/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "removeComments": true,
-    "outDir": "../lib" ,
-    "rootDir": ".",
-    "target": "es5",
-    "esModuleInterop": true,
-    "jsx": "react" 
-  }
-}

package/src/utils/get-type.ts

@@ -1,20 +0,0 @@
-import {Child} from '../constants/types';
-
-export default (element: Child): string => {
-  if (typeof element === 'string') {
-    return 'string';
-  }
-
-  if (element === null) {
-    return 'null';
-  }
-
-  if (Array.isArray(element)) {
-    throw new TypeError('Cannot type arrays');
-  }
-
-  const {type} = element;
-  const fn = type as () => void;
-
-  return fn.name || type as string;
-};

package/src/utils/type-helpers.ts

@@ -1 +0,0 @@
-export type SingleOrArray<T> = T | T[];

package/test/index.test.tsx

@@ -1,11 +0,0 @@
-import test from 'ava';
-import React from 'react';
-
-import render from '../src';
-import Message from '../src/components/message';
-
-test('can accept React component without erroring', t => {
-  const fn = () => render(<Message>child</Message>);
-
-  t.notThrows(fn);
-});

package/test/parser/parser.test.tsx

@@ -1,67 +0,0 @@
-import React from 'react';
-import test from 'ava';
-import {stub} from 'sinon';
-import proxyquire from 'proxyquire';
-
-const fooTransformer = stub();
-const divTransformer = stub().callsFake(elem => {
-  return {
-    type: 'div',
-    text: elem.props.children 
-  }
-});
-
-const parser = proxyquire('../../src/parser', {
-  '../transformers': {
-    default: {
-      Foo: fooTransformer,
-      div: divTransformer
-    }
-  }
-}).default;
-
-test('it returns a basic message if the child is just a string', t => {
-  const text = 'Hello, world!';
-  const result = parser(text);
-  const expected = {text};
-
-  t.deepEqual(result, expected);
-});
-
-const Foo = () => <p>Test</p>;
-test('it passes the item to the right transformer', t => {
-  const elem = (
-    <div>
-      <p>Hi</p>
-    </div>
-  );
-
-  const elem2 = <Foo/>;
-
-  parser([elem, elem2]);
-
-  t.true(divTransformer.calledWith(elem));
-  t.true(fooTransformer.calledWith(elem2));
-});
-
-test('it returns the result of the transformers', t => {
-  const res = parser(<div>Foo</div>);
-
-  t.deepEqual(res, {
-    blocks: [
-      {type: 'div', text: 'Foo'}
-    ]
-  });
-});
-
-test('it does not transform unkown types', t => {
-  const res = parser(<p>Hi</p>);
-
-  t.deepEqual(res, {});
-});
-
-test('it does not explode on null', t => {
-  const fn = () => parser(null);
-
-  t.notThrows(fn);
-});