Add dist/ folder to repository

Author: titouanmathis

.gitignore

@@ -1,7 +1,6 @@
 .idea
 .nyc_output
-dist
 coverage
 node_modules
 package-lock.json
-tmp
+tmp

dist/index.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("loader-utils");
+const twing_1 = require("twing");
+const visitor_1 = require("./visitor");
+const sha256 = require('crypto-js/sha256');
+const hex = require('crypto-js/enc-hex');
+const slash = require('slash');
+const validateOptions = require('schema-utils');
+const optionsSchema = {
+    type: 'object',
+    properties: {
+        environmentModulePath: {
+            type: 'string'
+        },
+        renderContext: {
+            type: 'object'
+        }
+    },
+    required: [
+        'environmentModulePath'
+    ],
+    additionalProperties: false
+};
+class PathSupportingArrayLoader extends twing_1.TwingLoaderArray {
+    getSourceContext(name, from) {
+        return super.getSourceContext(name, from).then((source) => {
+            return new twing_1.TwingSource(source.getCode(), source.getName(), name);
+        });
+    }
+}
+async function default_1(source) {
+    const callback = this.async();
+    const getTemplateHash = (name) => {
+        return this.mode !== 'production' ? name : hex.stringify(sha256(name));
+    };
+    const options = loader_utils_1.getOptions(this);
+    validateOptions(optionsSchema, options, 'Twing loader');
+    let resourcePath = slash(this.resourcePath);
+    let environmentModulePath = options.environmentModulePath;
+    let renderContext = options.renderContext;
+    this.addDependency(slash(environmentModulePath));
+    // require takes module name separated with forward slashes
+    let environment = require(slash(environmentModulePath));
+    let loader = environment.getLoader();
+    if (renderContext === undefined) {
+        let parts = [
+            `const env = require('${slash(environmentModulePath)}');`
+        ];
+        let key = getTemplateHash(resourcePath);
+        let sourceContext = new twing_1.TwingSource(source, `${key}`);
+        let tokenStream;
+        let nodeModule;
+        try {
+            tokenStream = environment.tokenize(sourceContext);
+            nodeModule = environment.parse(tokenStream);
+        }
+        catch (err) {
+            callback(err);
+            return null;
+        }
+        let visitor = new visitor_1.Visitor(loader, resourcePath, getTemplateHash);
+        await visitor.visit(nodeModule);
+        let precompiledTemplate = environment.compile(nodeModule);
+        parts.push(`let templatesModule = (() => {
+let module = {
+    exports: undefined
+};
+
+${precompiledTemplate}
+
+    return module.exports;
+})();
+`);
+        for (let foundTemplateName of visitor.foundTemplateNames) {
+            // require takes module name separated with forward slashes
+            parts.push(`require('${slash(foundTemplateName)}');`);
+        }
+        parts.push(`env.registerTemplatesModule(templatesModule, '${key}');`);
+        parts.push(`
+let loadTemplate = () => env.loadTemplate('${key}');
+
+module.exports = (context = {}) => {
+    return loadTemplate().then((template) => template.render(context));
+};`);
+        callback(null, parts.join('\n'));
+    }
+    else {
+        environment.setLoader(new twing_1.TwingLoaderChain([
+            new PathSupportingArrayLoader(new Map([
+                [resourcePath, source]
+            ])),
+            loader
+        ]));
+        environment.on('template', (name, from) => {
+            environment.getLoader().resolve(name, from)
+                .then((path) => this.addDependency(path))
+                .catch((e) => { });
+        });
+        callback(null, `module.exports = ${JSON.stringify(await environment.render(resourcePath, renderContext))};`);
+    }
+}
+exports.default = default_1;
+;

dist/visitor.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Visitor = void 0;
+const twing_1 = require("twing");
+const fs_1 = require("fs");
+const slash = require('slash');
+class Visitor {
+    constructor(loader, from, getTemplateHash) {
+        this._loader = loader;
+        this._from = new twing_1.TwingSource('', from, from);
+        this._getTemplateHash = getTemplateHash;
+        this._foundTemplateNames = [];
+    }
+    get foundTemplateNames() {
+        return this._foundTemplateNames;
+    }
+    async visit(node) {
+        const processExpressionNode = async (node) => {
+            if (node.type === null) {
+                return;
+            }
+            const pushValue = async (value) => {
+                if (await this._loader.exists(value, this._from)) {
+                    value = await this._loader.resolve(value, this._from);
+                    if (fs_1.existsSync(value)) {
+                        if (!this._foundTemplateNames.includes(value)) {
+                            this._foundTemplateNames.push(value);
+                        }
+                        value = this._getTemplateHash(slash(value));
+                    }
+                }
+                return value;
+            };
+            if (node.type.toString() === 'expression_array') {
+                for (let [index, constantNode] of node.getNodes()) {
+                    if (index % 2) {
+                        await processExpressionNode(constantNode);
+                    }
+                }
+            }
+            if (node.type.toString() === 'expression_conditional') {
+                let expr2 = node.getNode('expr2');
+                let expr3 = node.getNode('expr3');
+                await processExpressionNode(expr2);
+                await processExpressionNode(expr3);
+            }
+            if (node.type.toString() === 'expression_constant') {
+                node.setAttribute('value', await pushValue(node.getAttribute('value')));
+            }
+        };
+        if (node.type !== null) {
+            // include function
+            if ((node.type.toString() === 'expression_function') && (node.getAttribute('name') === 'include')) {
+                await processExpressionNode(node.getNode('arguments').getNode(0));
+            }
+            // import and include tags
+            if ((node.type.toString() === 'import') || (node.type.toString() === 'include')) {
+                if (node.hasNode('expr')) {
+                    await processExpressionNode(node.getNode('expr'));
+                }
+            }
+            // extends and embed tags
+            if ((node.type.toString() === 'module')) {
+                if (node.hasNode('parent')) {
+                    await processExpressionNode(node.getNode('parent'));
+                }
+                for (let embeddedTemplate of node.getAttribute('embedded_templates')) {
+                    await this.visit(embeddedTemplate);
+                }
+            }
+        }
+        for (let [key, subNode] of node.getNodes()) {
+            await this.visit(subNode);
+        }
+    }
+    ;
+}
+exports.Visitor = Visitor;

package.json

@@ -10,7 +10,7 @@
     "test:integration": "npm run build && ts-node node_modules/tape/bin/tape 'test/integration/**/test.ts' | tap-bail | tap-spec",
     "cover": "rimraf .nyc_output coverage && nyc npm run test:unit",
     "coverage": "nyc report --reporter=text-lcov | coveralls",
-    "prepare": "npm run build"
+    "prepublishOnly": "npm run build"
   },
   "files": [
     "dist/",

src/index.ts

@@ -39,7 +39,7 @@ class PathSupportingArrayLoader extends TwingLoaderArray {
     }
 }
 
-export default async function (this: loader.LoaderContext, source: string) {
+export default async function (this:loader.LoaderContext, source: string):Promise<string | Buffer | void | undefined> {
     const callback = this.async();
 
     const getTemplateHash = (name: string) => {