TypeScript Objects.readOptFrom方法代码示例

const buildBasicSettingsDataset = (editor: Editor, settingName, defaults, delimiter: Delimiter): BasicSelectDataset => {
  const rawFormats = Objects.readOptFrom<string>(editor.settings, settingName).getOr(defaults);
  const data = process(split(rawFormats, delimiter));
  return {
    type: 'basic',
    data
  };
};

 editor.on(showContextToolbarEvent, (e) => {
   const scopes = getScopes();
   // TODO: Have this stored in a better structure
   Objects.readOptFrom<Toolbar.ContextToolbar | Toolbar.ContextForm>(scopes.lookupTable, e.toolbarKey).each((ctx) => {
     launchContext(ctx, e.target === editor ? Option.none() : Option.some(e as DomElement));
     // Forms launched via this way get immediate focus
     InlineView.getContent(contextbar).each(Keying.focusIn);
   });
 });

const generateValueIfRequired = (item: SingleMenuItemApi): SingleMenuItemApi => {
  // Separators don't have a value, so just return the item
  if (isSeparator(item)) {
    return item;
  } else {
    // Use the value already in item if it has one.
    const itemValue = Objects.readOptFrom(item, 'value').getOrThunk(() => Id.generate('generated-menu-item'));
    return Merger.deepMerge({ value: itemValue }, item);
  }
};

const interpretParts: FormPartRenderer = (parts, spec, backstage) => {
  return Objects.readOptFrom(factories, spec.type).fold(
    () => {
      console.error(`Unknown factory type "${spec.type}", defaulting to container: `, spec);
      return spec as AlloySpec;
    },
    (factory: FormPartRenderer) => {
      return factory(parts, spec, backstage);
    }
  );
};

const derive = function (editor) {
  const base = Objects.readOptFrom(editor.settings, 'skin_url').fold(function () {
    return EditorManager.baseURL + '/skins/' + 'lightgray';
  }, function (url) {
    return url;
  });

  return {
    content: base + '/content.mobile.min.css',
    ui: base + '/skin.mobile.min.css'
  };
};

const register = function (editor, settings) {

  const isSelectedFor = function (format) {
    return function () {
      return editor.formatter.match(format);
    };
  };

  const getPreview = function (format) {
    return function () {
      const styles = editor.formatter.getCssText(format);
      return styles;
    };
  };

  const enrichSupported = function (item) {
    return Merger.deepMerge(item, {
      isSelected: isSelectedFor(item.format),
      getPreview: getPreview(item.format)
    });
  };

  // Item that triggers a submenu
  const enrichMenu = function (item) {
    return Merger.deepMerge(item, {
      isSelected: Fun.constant(false),
      getPreview: Fun.constant('')
    });
  };

  const enrichCustom = function (item) {
    const formatName = Id.generate(item.title);
    const newItem = Merger.deepMerge(item, {
      format: formatName,
      isSelected: isSelectedFor(formatName),
      getPreview: getPreview(formatName)
    });
    editor.formatter.register(formatName, newItem);
    return newItem;
  };

  const formats = Objects.readOptFrom(settings, 'style_formats').getOr(DefaultStyleFormats);

  const doEnrich = function (items) {
    return Arr.map(items, function (item) {
      if (Objects.hasKey(item, 'items')) {
        const newItems = doEnrich(item.items);
        return Merger.deepMerge(
          enrichMenu(item),
          {
            items: newItems
          }
        );
      } else if (Objects.hasKey(item, 'format')) {
        return enrichSupported(item);
      } else {
        return enrichCustom(item);
      }
    });
  };

  return doEnrich(formats);
};

const getValue = function (item) {
  return Objects.readOptFrom(item, 'format').getOr(item.title);
};

 return (parts, spec, backstage) => {
   return Objects.readOptFrom<string>(spec, 'name').fold(
     () => render(spec, backstage),
     (fieldName) => parts.field(fieldName, render(spec, backstage) as SimpleOrSketchSpec)
   );
 };

const classForPreset = (presets: Types.PresetTypes): string => {
  return Objects.readOptFrom<string>(presetClasses, presets).getOr(navClass);
};