TypeScript katamari.Strings类代码示例

const charMatches = (charCode: number, name: string, lowerCasePattern: string): boolean => {
  if (Strings.contains(String.fromCharCode(charCode).toLowerCase(), lowerCasePattern)) {
    return true;
  } else {
    return Strings.contains(name.toLowerCase(), lowerCasePattern) || Strings.contains(name.toLowerCase().replace(/\s+/g, ''), lowerCasePattern);
  }
};

  const getTextComponents = (): SimpleSpec[] => {
    const components: SimpleSpec[] = [];

    if (editor.getParam('elementpath', true, 'boolean')) {
      components.push(ElementPath.renderElementPath(editor, { }));
    }

    if (Strings.contains(editor.settings.plugins, 'wordcount')) {
      components.push(renderWordCount(editor, providersBackstage));
    }

    if (editor.getParam('branding', true, 'boolean')) {
      components.push(renderBranding());
    }

    if (components.length > 0) {
      return [{
        dom: {
          tag: 'div',
          classes: [ 'tox-statusbar__text-container']
        },
        components,
      }];
    }
    return [];
  };

 return textBefore(node, offset, block).bind(({node: endNode, offset: endOffset}) => {
   const text = endNode.data.substring(0, endOffset);
   for (let i = 0; i < patterns.length; i++) {
     const pattern = patterns[i];
     if (!Strings.endsWith(text, pattern.end)) {
       continue;
     }
     const newOffset = endOffset - pattern.end.length;
     // when the pattern only has a start or end we don't want to try to match inner patterns
     const hasContent = pattern.start.length > 0 && pattern.end.length > 0;
     const allowInner = hasContent ? Option.some(true) : Option.none();
     const recursiveMatch = allowInner.bind(() => {
       const patternsWithoutCurrent = patterns.slice();
       patternsWithoutCurrent.splice(i, 1);
       return findInlinePatternRec(dom, patternsWithoutCurrent, endNode, newOffset, block);
     }).fold(() => {
       const start = findInlinePatternStart(dom, pattern, endNode, newOffset, block, hasContent);
       return start.map(({node: startNode, offset: startOffset}) => {
         const range = generatePathRange(dom.getRoot(), startNode, startOffset, endNode, endOffset).getOrDie('Internal constraint violation');
         return [{ pattern, range }];
       });
     }, (areas) => {
       const outermostRange = resolvePathRange(dom.getRoot(), areas[areas.length - 1].range).getOrDie('Internal constraint violation');
       const start = findInlinePatternStart(dom, pattern, outermostRange.startNode, outermostRange.startOffset, block);
       return start.map(({node: startNode, offset: startOffset}) => {
         const range = generatePathRange(dom.getRoot(), startNode, startOffset, endNode, endOffset).getOrDie('Internal constraint violation');
         return areas.concat([{ pattern, range }]);
       });
     });
     if (recursiveMatch.isSome()) {
       return recursiveMatch;
     }
   }
   return Option.none();
 });

 const getResizeType = (editor): ResizeTypes => {
   // If autoresize is enabled, disable resize
   const fallback = !Strings.contains(editor.settings.plugins, 'autoresize');
   const resize = editor.getParam('resize', fallback);
   if (resize === false) {
     return ResizeTypes.None;
   } else if (resize === 'both') {
     return ResizeTypes.Both;
   } else {
     return ResizeTypes.Vertical;
   }
 };

const mergeTextNodes = (prevNode: Text, nextNode: Text, normalizeWhitespace?: boolean): Text => {
  const whitespaceOffset = Strings.rTrim(prevNode.data).length;
  // Merge the elements
  prevNode.appendData(nextNode.data);
  Remove.remove(Element.fromDom(nextNode));

  // Normalize the whitespace around the merged elements, to ensure it doesn't get lost
  if (normalizeWhitespace) {
    normalizeWhitespaceAfter(prevNode, whitespaceOffset);
  }

  return prevNode;
};

 children: Arr.map(items, (itemText) => {
   // itemText can have a trailing >, which means it has a caret
   const hasCaret = Strings.endsWith(itemText, '>');
   return s.element('div', {
     classes: [ arr.has('tox-collection__item') ],
     children: [
       s.element('div', { classes: [ arr.has('tox-collection__item-icon') ] }),
       s.element('div', {
         classes: [ arr.has('tox-collection__item-label') ],
         html: str.is(hasCaret ? itemText.substring(0, itemText.length - 1) : itemText)
       })
     ].concat(hasCaret ? [
       s.element('div', { classes: [ arr.has('tox-collection__item-caret') ] })
     ] : [ ])
   });
 })

const applyBlockPattern = (editor: Editor, pattern: BlockPattern) => {
  const dom = editor.dom;
  const rng = editor.selection.getRng();
  const block = dom.getParent(rng.startContainer, dom.isBlock);
  if (!block || !dom.is(block, 'p') || !isElement(block)) {
    return;
  }

  const walker = new TreeWalker(block, block);
  let node: Node;
  let firstTextNode: Text;
  while ((node = walker.next())) {
    if (isText(node)) {
      firstTextNode = node;
      break;
    }
  }
  if (!firstTextNode) {
    return;
  }
  if (!Strings.startsWith(firstTextNode.data, pattern.start)) {
    return;
  }
  if (Tools.trim(block.textContent).length === pattern.start.length) {
    return;
  }

  // add a marker to store the cursor position
  const cursor = editor.selection.getBookmark();
  if (pattern.type === 'block-format') {
    if (isBlockFormatName(pattern.format, editor.formatter)) {
      editor.undoManager.transact(() => {
        firstTextNode.deleteData(0, pattern.start.length);
        editor.formatter.apply(pattern.format);
      });
    }
  } else if (pattern.type === 'block-command') {
    editor.undoManager.transact(() => {
      firstTextNode.deleteData(0, pattern.start.length);
      editor.execCommand(pattern.cmd, false, pattern.value);
    });
  }
  // return the selection
  editor.selection.moveToBookmark(cursor);
};

const normalizeWhitespaceBefore = (node: Text, offset: number) => {
  const content = node.data.slice(0, offset);
  const whitespaceCount = content.length - Strings.rTrim(content).length;

  return normalize(node, offset - whitespaceCount, whitespaceCount);
};

 const rgbToHex = (value: string) => Strings.startsWith(value, 'rgb') ? dom.toHex(value) : value;

const dom = function (rawHtml): RawDomSchema {
  const html = Strings.supplant(rawHtml, {
    prefix: Styles.prefix()
  });
  return DomFactory.fromHtml(html);
};