TypeScript Option.none方法代码示例

const renderTextarea = (spec: TextareaFoo, providersBackstage: UiFactoryBackstageProviders): SketchSpec => {
  return renderTextField({
    name: spec.name,
    multiline: true,
    label: spec.label,
    placeholder: spec.placeholder,
    flex: true,
    classname: 'tox-textarea',
    validation: Option.none(),
  }, providersBackstage);
};

export const renderSelectBox = (spec: Types.SelectBox.SelectBox, providersBackstage: UiFactoryBackstageProviders): SketchSpec => {
  const translatedOptions = Arr.map(spec.items, (item) => {
    return {
      text: providersBackstage.translate(item.text),
      value: item.value
    };
  });

  // DUPE with TextField.
  const pLabel = spec.label.map((label) => renderLabel(label, providersBackstage));

  const pField = AlloyFormField.parts().field({
    // TODO: Alloy should not allow dom changing of an HTML select!
    dom: {  },
    selectAttributes: {
      size: spec.size
    },
    options: translatedOptions,
    factory: AlloyHtmlSelect,
    selectBehaviours: Behaviour.derive([
      Tabstopping.config({ }),
      AddEventsBehaviour.config('selectbox-change', [
        AlloyEvents.run(NativeEvents.change(), (component, _) => {
          AlloyTriggers.emitWith(component, formChangeEvent, { name: spec.name } );
        })
      ])
    ])
  });

  const chevron = spec.size > 1 ? Option.none() :
    Option.some({
        dom: {
          tag: 'div',
          classes: ['tox-selectfield__icon-js'],
          innerHtml: Icons.get('chevron-down', providersBackstage.icons)
        }
      });

  const selectWrap: SimpleSpec = {
    dom: {
      tag: 'div',
      classes: ['tox-selectfield']
    },
    components: Arr.flatten([[pField], chevron.toArray()])
  };

  return AlloyFormField.sketch({
    dom: {
      tag: 'div',
      classes: ['tox-form__group']
    },
    components: Arr.flatten<AlloySpec>([pLabel.toArray(), [selectWrap]])
  });
};

 function (cells, _env) {
   if (cells.length === 0) {
     return Option.none();
   }
   return TableSelection.retrieveBox(table, Ephemera.firstSelectedSelector(), Ephemera.lastSelectedSelector()).bind(function (bounds) {
     return cells.length > 1 ? Option.some({
       bounds: Fun.constant(bounds),
       cells: Fun.constant(cells)
     }) : Option.none();
   });
 },

const getCloneElements = (editor: Editor): Option<string[]> => {
  const cloneElements = editor.getParam('table_clone_elements');

  if (Type.isString(cloneElements)) {
    return Option.some(cloneElements.split(/[ ,]/));
  } else if (Array.isArray(cloneElements)) {
    return Option.some(cloneElements);
  } else {
    return Option.none();
  }
};

export const getLinkInformation = (editor: Editor): Option<LinkInformation> => {
  if (editor.settings.typeahead_urls === false) {
    return Option.none();
  }

  return Option.some({
    targets: LinkTargets.find(editor.getBody()),
    anchorTop: getTextSetting(editor.settings, 'anchor_top', '#top').getOrUndefined(),
    anchorBottom: getTextSetting(editor.settings, 'anchor_bottom', '#bottom').getOrUndefined()
  });
};

 (store, doc, body) => {
   return GuiFactory.build(
     renderButton({
       name: 'test-button',
       text: 'ButtonText',
       disabled: false,
       primary: true,
       icon: Option.none()
     }, store.adder('button.action'), TestProviders)
   );
 },

const findReplacementPattern = (patterns: ReplacementPattern[], startSearch: number, text: string): Option<ReplacementMatch> => {
  for (let i = 0; i < patterns.length; i++) {
    const index = text.lastIndexOf(patterns[i].start, startSearch);
    if (index !== -1) {
      return Option.some({
        pattern: patterns[i],
        startOffset: index
      });
    }
  }
  return Option.none();
};

const getEditableImage = function (editor: Editor, elem) {
  const isImage = (imgNode) => editor.dom.is(imgNode, 'img:not([data-mce-object],[data-mce-placeholder])');
  const isEditable = (imgNode) => isImage(imgNode) && (isLocalImage(editor, imgNode) || isCorsImage(editor, imgNode) || editor.settings.imagetools_proxy);

  if (isFigure(editor, elem)) {
    const imgOpt = getFigureImg(elem);
    return imgOpt.map((img) => {
      return isEditable(img.dom()) ? Option.some(img.dom()) : Option.none();
    });
  }
  return isEditable(elem) ? Option.some(elem) : Option.none();
};

const getListType = (list: Element): Option<ListType> => {
  switch (Node.name(list)) {
    case 'ol':
      return Option.some(ListType.OL);
    case 'ul':
      return Option.some(ListType.UL);
    case 'dl':
      return Option.some(ListType.DL);
    default:
      return Option.none();
  }
};