@videinfra/static-website-builder 2.0.9 → 2.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@videinfra/static-website-builder",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "description": "Customizable static site project builder",
   "license": "MIT",
   "engines": {

package/tasks/sitemap/task.js

@@ -2,7 +2,7 @@ import gulp from 'gulp';
 import gulpif from 'gulp-if';
 import nanomemoize from 'nano-memoize';
 import ignore from 'gulp-ignore';
-import gulpSitemap from 'gulp-sitemap';
+import gulpSitemap from '../../vendor/gulp-sitemap/index.js';
 
 import { getDestPath } from './../../lib/get-path.js';
 import { getTaskConfig } from './../../lib/get-config.js';

package/vendor/gulp-sitemap/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Gilad Peleg <gilad@giladpeleg.com> (https://www.giladpeleg.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/vendor/gulp-sitemap/README.md

@@ -0,0 +1,293 @@
+# [gulp](https://github.com/wearefractal/gulp)-sitemap
+> Generate a search engine friendly sitemap.xml using a Gulp stream
+
+[![NPM version](http://img.shields.io/npm/v/gulp-sitemap.svg?style=flat)](https://www.npmjs.org/package/gulp-sitemap)
+[![NPM Downloads](http://img.shields.io/npm/dm/gulp-sitemap.svg?style=flat)](https://www.npmjs.org/package/gulp-sitemap)
+[![Build Status](http://img.shields.io/travis/pgilad/gulp-sitemap/master.svg?style=flat)](https://travis-ci.org/pgilad/gulp-sitemap)
+
+Easily generate a search engine friendly sitemap.xml from your project.
+
+:bowtie: Search engines love the sitemap.xml and it helps SEO as well.
+
+For information about sitemap properties and structure, see the [wiki for sitemaps](http://www.wikiwand.com/en/Sitemaps)
+
+## Install
+
+Install with [npm](https://npmjs.org/package/gulp-sitemap)
+
+```bash
+$ npm install --save-dev gulp-sitemap
+```
+
+## Example
+
+```js
+var gulp = require('gulp');
+var sitemap = require('gulp-sitemap');
+
+gulp.task('sitemap', function () {
+    gulp.src('build/**/*.html', {
+            read: false
+        })
+        .pipe(sitemap({
+            siteUrl: 'http://www.amazon.com'
+        }))
+        .pipe(gulp.dest('./build'));
+});
+```
+
+* `siteUrl` is required.
+* `index.html` will be turned into directory path `/`.
+* `404.html` will be skipped automatically. No need to unglob it.
+
+Let's see an example of how we can create and output a sitemap, and then return to the original stream files:
+```js
+var gulp = require('gulp');
+var sitemap = require('gulp-sitemap');
+var save = require('gulp-save');
+
+gulp.task('html', function() {
+    gulp.src('*.html', {
+          read: false
+        })
+        .pipe(save('before-sitemap'))
+        .pipe(sitemap({
+                siteUrl: 'http://www.amazon.com'
+        })) // Returns sitemap.xml
+        .pipe(gulp.dest('./dist'))
+        .pipe(save.restore('before-sitemap')) //restore all files to the state when we cached them
+        // -> continue stream with original html files
+        // ...
+});
+```
+
+## Options
+
+### siteUrl
+
+Your website's base url. This gets prepended to all documents locations.
+
+Type: `string`
+
+Required: `true`
+
+### fileName
+
+Determine the output filename for the sitemap.
+
+Type: `string`
+
+Default: `sitemap.xml`
+
+Required: `false`
+
+### changefreq
+
+Gets filled inside the sitemap in the tag `<changefreq>`. Not added by default.
+
+Type: `string`
+
+Default: `undefined`
+
+Valid Values: `['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never']`
+
+Required: `false`
+
+**Note: any falsey value is also valid and will skip this xml tag**
+
+### priority
+
+Gets filled inside the sitemap in the tag `<priority>`. Not added by default.
+
+Type: `string|function`
+
+Default: `undefined`
+
+Valid Values: `0.0` to `1.0`
+
+Required: `false`
+
+**Note: any falsey (non-zero) value is also valid and will skip this xml tag**
+
+Example using a function as `priority`:
+
+
+```js
+priority: function(siteUrl, loc, entry) {
+    // Give pages inside root path (i.e. no slashes) a higher priority
+    return loc.split('/').length === 0 ? 1 : 0.5;
+}
+```
+
+### lastmod
+
+The file last modified time.
+
+- If `null` then this plugin will try to get the last modified time from the stream vinyl file, or use `Date.now()` as lastmod.
+- If the value is not `null` - It will be used as lastmod.
+- When `lastmod` is a function, it is executed with the current file given as parameter. (Note: the function is expected to be sync).
+- A string can be used to manually set a fixed `lastmod`.
+
+Type: `string|datetime|function`
+
+Default: `null`
+
+Required: `false`
+
+Example that uses git to get lastmod from the latest commit of a file:
+
+```js
+lastmod: function(file) {
+  var cmd = 'git log -1 --format=%cI "' + file.relative + '"';
+  return execSync(cmd, {
+    cwd: file.base
+  }).toString().trim();
+}
+```
+
+**Note: any falsey (other than null) value is also valid and will skip this xml tag**
+
+### newLine
+
+How to join line in the target sitemap file.
+
+Type: `string`
+
+Default: Your OS's new line, mostly: `\n`
+
+Required: `false`
+
+### spacing
+
+How should the sitemap xml file be spaced. You can use `\t` for tabs, or `  ` with 2
+spaces if you'd like.
+
+Type: `string`
+
+Default: `    ` (4 spaces)
+
+Required: `false`
+
+### noindex
+
+Exclude pages from the sitemap when the `robots` meta tag is set to `noindex`. The plugin needs to be able to read the contents of the files for this to have an effect.
+
+Type: `boolean`
+
+Default: `false`
+
+Required: `false`
+
+### images
+
+For generate sitemap for images per page, just enable images flag to `true`
+
+Type: `boolean`
+
+Default: `undefined`
+
+Required: `false`
+
+
+### mappings
+
+An object to custom map pages to their own configuration.
+
+This should be an array with the following structure:
+
+Type: `array`
+
+Default: `[]`
+
+Required: `false`
+
+Example:
+
+```js
+mappings: [{
+    pages: [ 'minimatch pattern' ],
+    changefreq: 'hourly',
+    priority: 0.5,
+    lastmod: Date.now(),
+    getLoc(siteUrl, loc, entry) {
+        // Removes the file extension if it exists
+        return loc.replace(/\.\w+$/, '');
+    },
+    hreflang: [{
+        lang: 'ru',
+        getHref(siteUrl, file, lang, loc) {
+            return 'http://www.amazon.ru/' + file;
+        }
+    }]
+},
+//....
+]
+```
+
+- Every file will be matched against the supplied patterns
+- Only defined attributes for a matched file are applied.
+- Only the first match will apply, so consequent matches for the filename will not apply.
+- Possible attributes to set: `hreflang`, `changefreq`, `priority`, `loc` and `lastmod`.
+- All rules applying to [options](#options) apply to the attributes that can overridden.
+
+##### pages
+
+Type: `array`
+
+Required: `true`
+
+This is an array with [minimatch](https://github.com/isaacs/minimatch) patterns to match the
+relevant pages to override.
+Every file will be matched against the supplied patterns.
+
+Uses [multimatch](https://github.com/sindresorhus/multimatch) to match patterns against filenames.
+
+Example: `pages: ['home/index.html', 'home/see-*.html', '!home/see-admin.html']`
+
+##### hreflang
+
+Matching pages can get their `hreflang` tags set using this option.
+
+The input is an array like so:
+
+```js
+hreflang: [{
+    lang: 'ru',
+    getHref: function(siteUrl, file, lang, loc) {
+        // return href src for the hreflang. For example:
+        return 'http://www.amazon.ru/' + file;
+    }
+}]
+```
+
+##### getLoc
+
+Matching pages can get their `loc` tag modified by using a function.
+
+```js
+getLoc: function(siteUrl, loc, entry) {
+    return loc.replace(/\.\w+$/, '');
+}
+```
+
+#### verbose
+
+Type: `boolean`
+
+Required: `false`
+
+Default: `false`
+
+If true, will log the number of files that where handled.
+
+## Complementary plugins
+
+- [gulp-sitemap-files](https://github.com/adam-lynch/gulp-sitemap-files) - Get all files listed in a sitemap (Perhaps one generated from this plugin)
+
+## Thanks
+
+To [grunt-sitemap](https://github.com/RayViljoen/grunt-sitemap) for the inspiration on writing this.
+
+## License
+
+MIT © [Gilad Peleg](https://www.giladpeleg.com)

package/vendor/gulp-sitemap/index.js

@@ -0,0 +1,91 @@
+'use strict';
+const chalk = require('chalk');
+const defaults = require('lodash/defaults');
+const log = require('fancy-log');
+const path = require('path');
+const PluginError = require('plugin-error');
+const through = require('through2');
+const Vinyl = require('vinyl');
+
+const pluginName = 'gulp-sitemap';
+const sitemap = require('./lib/sitemap');
+
+module.exports = function (options = {}) {
+    const config = defaults({}, options, {
+        changefreq: undefined,
+        fileName: 'sitemap.xml',
+        lastmod: null,
+        mappings: [],
+        newLine: '\n',
+        priority: undefined,
+        spacing: '    ',
+        verbose: false,
+        noindex: false
+    });
+    const entries = [];
+    let firstFile;
+    let msg;
+
+    if (!config.siteUrl) {
+        msg = 'siteUrl is a required param';
+        throw new PluginError(pluginName, msg);
+    }
+    if (options.changeFreq) {
+        msg = chalk.magenta('changeFreq') + ' has been deprecated. Please use ' + chalk.cyan('changefreq');
+        throw new PluginError(pluginName, msg);
+    }
+    // site url should have a trailing slash
+    if (config.siteUrl.slice(-1) !== '/') {
+        config.siteUrl = config.siteUrl + '/';
+    }
+
+    return through.obj(function (file, enc, callback) {
+            //we handle null files (that have no contents), but not dirs
+            if (file.isDirectory()) {
+                return callback(null, file);
+            }
+
+            if (file.isStream()) {
+                msg = 'Streaming not supported';
+                return callback(new PluginError(pluginName), msg);
+            }
+
+            //skip 404 file
+            if (/404\.html?$/i.test(file.relative)) {
+                return callback();
+            }
+
+            if(options.noindex){
+                const contents = file.contents.toString();
+                if (/<meta [^>]*?noindex/i.test(contents)) {
+                    return callback();
+                }
+            }
+
+            if (!firstFile) {
+                firstFile = file;
+            }
+
+            const entry = sitemap.getEntryConfig(file, config);
+            entries.push(entry);
+            callback();
+        },
+        function (callback) {
+            if (!firstFile) {
+                return callback();
+            }
+            const contents = sitemap.prepareSitemap(entries, config);
+            if (options.verbose) {
+                msg = 'Files in sitemap: ' + entries.length;
+                log(pluginName, msg);
+            }
+            //create and push new vinyl file for sitemap
+            this.push(new Vinyl({
+                cwd: firstFile.cwd,
+                base: firstFile.cwd,
+                path: path.join(firstFile.cwd, config.fileName),
+                contents: Buffer.from(contents)
+            }));
+            callback();
+        });
+};

package/vendor/gulp-sitemap/lib/sitemap.js

@@ -0,0 +1,207 @@
+/**
+ * Changes by Kaspars Zuks:
+ * - Removed xmlns:image attribute from `urlset` if images is false
+ */
+'use strict';
+const fs = require('fs');
+const defaults = require('lodash/defaults');
+const find = require('lodash/find');
+const includes = require('lodash/includes');
+const multimatch = require('multimatch');
+const slash = require('slash');
+const pick = require('lodash/pick');
+
+const header = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
+];
+
+const headerHref = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">'
+];
+
+const footer = ['</urlset>'];
+const allowedProperties = ['getLoc', 'lastmod', 'priority', 'changefreq', 'hreflang'];
+
+function getEntryConfig(file, siteConfig) {
+    const relativePath = file.relative;
+    const mappingsForFile = find(siteConfig.mappings, function(item) {
+        return multimatch(relativePath, item.pages).length > 0;
+    }) || {};
+
+    const entry = defaults(
+        {},
+        pick(mappingsForFile, allowedProperties),
+        pick(siteConfig, allowedProperties)
+    );
+
+    // if images enabled add headerHref
+    if (siteConfig.images) {
+        header[1] = '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">';
+        headerHref[1] = '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">'
+    }
+
+    if (entry.lastmod === null) {
+        // calculate mtime manually
+        entry.lastmod = file.stat && file.stat.mtime || Date.now();
+    } else if (typeof entry.lastmod === 'function') {
+        entry.lastmod = entry.lastmod(file);
+    }
+
+    //turn index.html into -> /
+    let relativeFile = relativePath.replace(/(\/|\\|^)index\.html?$/, '/');
+    if (relativeFile === '/') {
+        relativeFile = '';
+    }
+    //url location. Use slash to convert windows \\ or \ to /
+    const adjustedFile = slash(relativeFile);
+    entry.loc = siteConfig.siteUrl + adjustedFile;
+    entry.file = adjustedFile;
+    entry.source = file.history[0];
+
+    return entry;
+}
+
+function wrapTag(tag, value) {
+    return `
+        <${ tag }>${ value }</${ tag }>
+    `;
+}
+
+function createImageSitemap(imageURL) {
+    return `
+        <image:image>
+            <image:loc>${imageURL}</image:loc>
+        </image:image>
+    `;
+}
+
+function notIsHTTPURL(text) {
+    return !(/https?:\/\//ig).test(text);
+}
+
+function getImagesUrl(entry, siteConfig) {
+    const reImageMatch = /<img\s+src="((https?:\/\/)?[\w\.\/\-@\?=&]+)"/ig;
+    const reSourceMatch = /"((https?:\/\/)?[\w\.\/\-@\?=&]+)"/ig;
+    const html = fs.readFileSync(entry.source, { encoding : 'utf8'})
+    const images = html.match(reImageMatch);
+
+    if (images === null) {
+        return [];
+    }
+
+    const URLs = images.map(image => {
+        let currentURL = image.match(reSourceMatch)[0].replace(/^\"|\"$/ig, '');
+
+        if (notIsHTTPURL(currentURL)) {
+            currentURL = currentURL.replace(/^\/|\.\//, '');
+            currentURL = siteConfig.siteUrl + currentURL;
+        }
+
+        return currentURL;
+    });
+
+    return URLs;
+}
+
+function generateImagesMap(entry, siteConfig) {
+    let imagesURLS = [];
+    let XMLImageList = '';
+
+    // Crawling page for images
+    imagesURLS = getImagesUrl(entry, siteConfig);
+
+    // if truthy create image sitemap
+    if (imagesURLS.length) {
+        XMLImageList = imagesURLS.map(imageURL => createImageSitemap(imageURL)).join('')
+    }
+
+    return XMLImageList;
+}
+
+/**
+ * processEntry
+ *
+ * @param entry
+ * @param siteConfig
+ * @return {string}
+ */
+function processEntry(entry, siteConfig) {
+    const returnArr = [siteConfig.spacing + '<url>'];
+
+    const loc = entry.getLoc ? entry.getLoc(siteConfig.siteUrl, entry.loc, entry) : entry.loc;
+    returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('loc', loc) + (siteConfig.images ? generateImagesMap(entry, siteConfig) : ''));
+
+    let lastmod = entry.lastmod;
+    if (lastmod) {
+        //format mtime to ISO (same as +00:00)
+        lastmod = new Date(lastmod).toISOString();
+        returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('lastmod', lastmod));
+    }
+
+    const changefreq = entry.changefreq;
+    if (changefreq) {
+        returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('changefreq', changefreq));
+    }
+
+    let priority;
+
+    if (typeof entry.priority === 'function') {
+        priority = entry.priority(siteConfig.siteUrl, entry.loc, entry);
+    } else if (typeof entry.priority !== 'undefined') {
+        priority = entry.priority;
+    }
+    if (typeof priority !== 'undefined') {
+        returnArr.push(siteConfig.spacing + siteConfig.spacing + wrapTag('priority', priority));
+    }
+
+    const hreflang = entry.hreflang;
+    if (hreflang && hreflang.length > 0) {
+        const file = entry.file;
+        hreflang.forEach(function(item) {
+            const href = item.getHref(siteConfig.siteUrl, file, item.lang, loc);
+            const tag = '<xhtml:link rel="alternate" hreflang="' + item.lang + '" href="' + href + '" />';
+            returnArr.push(siteConfig.spacing + siteConfig.spacing + tag);
+        });
+    }
+
+    returnArr.push(siteConfig.spacing + '</url>');
+    return returnArr.join(siteConfig.newLine);
+}
+
+function prepareSitemap(entries, config) {
+    const entriesHref = entries.some(function(entry) {
+        return entry && entry.hreflang && entry.hreflang.length;
+    });
+    return (entriesHref ? headerHref : header)
+        .concat(entries.map(function(entry) {
+            return processEntry(entry, config);
+        }))
+        .concat(footer)
+        .join(config.newLine)
+        .toString();
+}
+
+const VALID_CHANGE_FREQUENCIES = [
+    'always',
+    'hourly',
+    'daily',
+    'weekly',
+    'monthly',
+    'yearly',
+    'never'
+];
+
+function isChangefreqValid(changefreq) {
+    // empty changefreq is valid
+    if (!changefreq) {
+        return true;
+    }
+    return includes(VALID_CHANGE_FREQUENCIES, changefreq.toLowerCase());
+}
+
+exports.getEntryConfig = getEntryConfig;
+exports.isChangefreqValid = isChangefreqValid;
+exports.prepareSitemap = prepareSitemap;
+exports.processEntry = processEntry;

package/vendor/gulp-sitemap/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "gulp-sitemap",
+  "version": "8.0.0",
+  "description": "Generate a search engine friendly sitemap.xml using a Gulp stream",
+  "repository": "pgilad/gulp-sitemap",
+  "license": "MIT",
+  "author": "Gilad Peleg <gilad@giladpeleg.com> (https://www.giladpeleg.com)",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=10"
+  },
+  "scripts": {
+    "test": "mocha -R spec test/*.spec.js"
+  },
+  "keywords": [
+    "gulpplugin",
+    "gulp",
+    "js",
+    "javascript",
+    "SEO",
+    "sitemap",
+    "sitemap.xml",
+    "Google",
+    "search-engine",
+    "xml"
+  ],
+  "dependencies": {
+    "chalk": "^2.4.2",
+    "fancy-log": "^1.3.3",
+    "lodash": "^4.17.15",
+    "multimatch": "^4.0.0",
+    "plugin-error": "^1.0.1",
+    "slash": "^3.0.0",
+    "through2": "^3.0.1",
+    "vinyl": "^2.2.0"
+  },
+  "devDependencies": {
+    "gulp": "^4.0.2",
+    "gulp-rename": "^1.4.0",
+    "mocha": "^6.2.2",
+    "should": "^13.2.3",
+    "strip-ansi": "^5.2.0"
+  }
+}