library-ts/browser/templates/TemplateSourceMatchers.ts

import { ExtendedRegex } from "../text/ExtendedRegex";
import { TemplateSource } from "./TemplateSource";
import { TemplatesSourceLexer } from "./TemplatesSourceLexer";

export enum TemplateMatchType
{
  SPECIAL,
  SELECTOR,
  ATTRIBUTE,
  PASS_THROUGH
}

export class TemplateSourceMatchers
{
  static readonly regex = ExtendedRegex.create( 
    /@\{(\P):(\V)\}\[(\P)\]|@\{(\V)\}\[(\P)\]|@\{(\P):(\V)\}|@\{(\V)\}|@\[(\P)\]|(@\{\})/g 
  );
    

  static readonly matchers = 
  [
    {
      type: 
        TemplatesSourceLexer.SPECIAL_SELECTOR_AND_ATTRIBUTE,
      values: 
        [ TemplateMatchType.SPECIAL, TemplateMatchType.SELECTOR, TemplateMatchType.ATTRIBUTE ]
    },

    {
      type: 
        TemplatesSourceLexer.SELECTOR_AND_ATTRIBUTE,
      values: 
        [ TemplateMatchType.SELECTOR, TemplateMatchType.ATTRIBUTE ]
    },

    {
      type: 
        TemplatesSourceLexer.SPECIAL_SELECTOR,
      values: 
        [ TemplateMatchType.SPECIAL, TemplateMatchType.SELECTOR ]
    },

    {
      type: 
        TemplatesSourceLexer.SELECTOR,
      values: 
        [ TemplateMatchType.SELECTOR ]
    },

    {
      type: 
        TemplatesSourceLexer.ATTRIBUTE,
      values: 
        [ TemplateMatchType.ATTRIBUTE ]
    },

    {
      type: 
        TemplatesSourceLexer.PASS_THROUGH,
      values: 
        [ TemplateMatchType.PASS_THROUGH ]
    }
  ];

  static createTemplateSource( match:RegExpExecArray )
  {
    let elementSource = new TemplateSource();

    var offset = 1;

    if ( match == null || offset > match.length )
    {
      elementSource.defaultValue = "";
      console.log( "No matching value >> ", match );
      return elementSource;
    }

    for ( let i = 0; i < this.matchers.length; i++ )
    {
      let matcher = this.matchers[ i ];

      if ( ! match[ offset ] )
      { 
        offset += matcher.values.length;
        continue;
      }
      
      let matchValuesOffset = offset;

      for ( let j = 0; j < matcher.values.length; j++ )
      {
        let value = matcher.values[ j ];
        let valueOffset = matchValuesOffset + j;

        if ( TemplateMatchType.SPECIAL === value )
        {
          elementSource.special = match[ valueOffset ];
        }
        else if ( TemplateMatchType.SELECTOR === value )
        {
          elementSource.selector = match[ valueOffset ];
        }
        else if ( TemplateMatchType.ATTRIBUTE === value )
        {
          elementSource.attribute = match[ valueOffset ];
        }
        else if ( TemplateMatchType.PASS_THROUGH === value )
        {
          elementSource.innerHTML = true;
        } 
      }

      return elementSource;
    }

    return elementSource;
  }
}