Top 10 Examples of "twig in functional component" in JavaScript

let storiesOfMatch = storiesOf.exec(story)

  let add = /(?:add\([\n\s]*)(?:')(.+)(?:',)/gim
  let addMatch = add.exec(story)
  while (addMatch !== null) {
    data.storybookParams.push({
      path: 'Storybook/' + addMatch[1].replace('\\', ''),
      params: '?selectedKind=' + encodeURI(storiesOfMatch[1]) + '&selectedStory=' + encodeURI(addMatch[1])
    })
    addMatch = add.exec(story)
  }

  // Add check for no-ssr folder.

  // Render template.
  Twig.renderFile(path.join(__dirname, '/README_template.md'), data, (err, html) => {
    if (err) {
      console.log(err)
    } else {
      // Strip comments & write.
      html = html.replace(/\n/gi, '')
      fs.writeFileSync(directory + 'README.md', html)
    }
  })
}

, function (require, exports, module) {
        var Backbone = require("backbone")
            , twig = require("twig").twig
        
            // Load the template for a "Tweet"
            //     This template only needs to be loaded once. It will be compiled at
            //     load time and can be rendered separately for each Tweet.
            , template = twig({
                href: 'templates/tweet.twig'
                , async: false
            })
            
            , TweetView = Backbone.View.extend({
                tagName: "li"
                , className: "tweet"

                // Create the Tweet view
                , initialize: function() {
                    // Re-render the tweet if the backing model changes
                    this.model.bind('change', this.render, this);

                    // Remove the Tweet if the backing model is removed.
                    this.model.bind('destroy', this.remove, this);
                }

pathArray = pathArray.concat(elt[flatten]);
            } else {
              pathArray.push(elt);
            }
          }
        }
        for (i = 0, len = pathArray.length; i < len; i++) { 
          var tt = Twig.twig(merge(twigOpts,{path: template}));
          // compute destination path by inserting '_n'
          var destPath = dest.replace(/(.*)(\.[^\.]+)$/, replacer);
          actualData.dataPath = pathArray[i];
          grunt.file.write(destPath, tt.render(actualData));
        }
        actualData.dataPath = pathArray;
      } else {
        var twigTemplate = Twig.twig(merge(twigOpts,{path: template}));
        grunt.file.write(dest, twigTemplate.render(actualData));
      }
    }
  };

, function (require, exports, module) {
        var twig = require("twig").twig
            , Backbone = require("backbone")
            , feed = require("feed").feed

            // The application template
            , template = twig({
                href: 'templates/app.twig'
                , async: false
            })
            
            , FeedView = require("feedView").FeedView
            , feedView = new FeedView

            , AppView = Backbone.View.extend({
                tagName: "div"
                , className: "app"

                // Bind to the buttons in the template
                , events: {
                    "click .reloadTweets": "reload"
                    , "click .changeUser": "changeUser"
                    , "click .twitter_user": "twitterLink"

if (!template.baseTemplate) {
        // build baseTemplate form parent component
        if (template.extendsFrom) {
            let templateConfig = {};

            if (hasBlocks(template.extendsFrom)) {
                // use baseTemplate from parent component
                const extendTemplate = templateRegistry.get(template.extendsFrom);

                templateConfig = {
                    id: `${componentName}-baseTemplate`,
                    data: extendTemplate.baseTemplate.tokens
                };

                template.baseTemplate = Twig.twig(templateConfig);
            } else if (template.overrides.length > 0) {
                // use first override as baseTemplate
                // and remove it from overrides
                const firstOverride = template.overrides.shift();

                template.baseTemplate = firstOverride;
            } else {
                warn(componentName, 'has no overrides or template to extend from!');
                return '';
            }
        } else {
            warn('missing baseTemplate', componentName);
            return '';
        }
    }

var Twig = require("twig");
var path = require("path");
var async = require("async");

var compilerFactory = require("./compiler");
var getOptions = require("./getOptions");
var utils = require('./utils');

Twig.cache(false);

// shared resolve map to store includes that are resolved by webpack
// so they can be used in the compiled templates
var resolveMap = {};

module.exports = function (source) {
    var loaderApi = this;
    var loaderAsyncCallback = this.async();
    var context = loaderApi.rootContext || loaderApi.options.context;
    this.cacheable && this.cacheable();

    // the path is saved to resolve other includes from
    var path = require.resolve(loaderApi.resource);

    // this will be the template id for this resource,
    // this id is also be generated in the copiler when this resource is included

function loader() {
  // async
  const callback = this.async();
  this.addContextDependency(join(process.cwd(), 'src', 'views'));
  this.addContextDependency(join(process.cwd(), 'src', 'mock'));
  const { getMockData, ...others } = loaderUtils.getOptions(this);
  Twig.cache(false);
  this.cacheable && this.cacheable();  // eslint-disable-line
  const currentFilePath = require.resolve(this.resource);
  /**
   * not use source, but use path. so as to support base dir.
   * 为了与后端保持一致，开启 base，开启绝对路径的使用
   */
  const template = Twig.twig({
    id: currentFilePath, // id is optional, but useful for referencing the template later
    base: join(process.cwd(), 'src', 'views'),
    // data: source,
    // allowInlineIncludes: true,
    async: false,
    path: currentFilePath,
    ...others,
  });
  // 使用data参数时，base会被过滤掉

.add('twig.js', async function () {
        Twig.cache(false);

        let template = Twig.twig({
            autoescape: true,
            data: indexSource,
            allowInlineIncludes: true
        });

        Twig.twig({
            autoescape: true,
            id: 'include',
            data: includeSource
        });

        await template.renderAsync({foo: 'bar'});
    })
    // add listeners

if (!isFunction(fn)) {
        grunt.fail.fatal('"' + name + '" needs to be a function!');
      }
      Twig.extendFunction(name, fn);
    }.bind(this));

    // apply defined filters
    Object.keys(this.options.filters).forEach(function(name) {
      var fn = this.options.filters[name];
      if (!isFunction(fn)) {
        grunt.fail.fatal('"' + name + '" needs to be a function!');
      }
      Twig.extendFilter(name, fn);
    }.bind(this));

    Twig.cache(this.options.cache);
  }

}

    if (query.extend) {
      Twig.extend(query.extend);
    }

    if (typeof data === 'function') {
      data = data(this);
      if (typeof data !== 'object') {
        this.emitError('data parameter should return an object');
      }
    }

    const registry = [];

    Twig.extend((Twig) => {
      const defaultSave = Object.assign(Twig.Templates.save);
      // eslint-disable-next-line no-param-reassign
      Twig.Templates.save = function customSave(template) {
        if (template.path) {
          registry.push(path.normalize(template.path));
        }
        return defaultSave.call(this, template);
      };
    });

    const template = Twig.twig(options);
    const output = template.render(data);

    registry.forEach(this.addDependency);

    Twig.extend((Twig) => {